Survey II Assignment

Loading libraries

rm(list = ls())
library(MASS)
library(tidyverse)
library(haven)
library(readxl)
library(xml2)
library(rvest)
library(janitor)
library(DataExplorer)
library(countrycode)
library(explore)
library(lme4)
library(lmerTest)
library(broom.mixed)
library(ggplot2)
library(dplyr)
library(scales)
library(tidyr)
library(kableExtra)
library(gmodels)
library(flexplot)
library(corrplot)
library(DescTools)
library(caret)
library(ROSE)
library(randomForest)
library(pROC)
library(mice)
library(glmnet)
library(fastDummies)

Loading data

Survey data

data_raw <- read_dta("ZA7575.dta")

Country-level data sets

This is for joins:

# building a df with country names and codes for the EU-28
codelist <- countrycode::codelist |> 
  select(country.name.en, iso.name.en, un.name.en, cow.name, ecb, eurostat, iso2c, iso3c, eu28) |> 
  filter(!is.na(eu28)) 

GDP per capita, PPP (constant 2021 international $)

Retrieved from the World Bank (https://data.worldbank.org/indicator/NY.GDP.PCAP.PP.KD) for the year 2019.

gdp_data <- read_csv("gdp_pc_ppp_2021.csv", skip = 4, show_col_types = FALSE)
## New names:
## • `` -> `...69`
head(gdp_data)
## # A tibble: 6 × 69
##   `Country Name`  `Country Code` `Indicator Name` `Indicator Code` `1960` `1961`
##   <chr>           <chr>          <chr>            <chr>            <lgl>  <lgl> 
## 1 Aruba           ABW            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## 2 Africa Eastern… AFE            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## 3 Afghanistan     AFG            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## 4 Africa Western… AFW            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## 5 Angola          AGO            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## 6 Albania         ALB            GDP per capita,… NY.GDP.PCAP.PP.… NA     NA    
## # ℹ 63 more variables: `1962` <lgl>, `1963` <lgl>, `1964` <lgl>, `1965` <lgl>,
## #   `1966` <lgl>, `1967` <lgl>, `1968` <lgl>, `1969` <lgl>, `1970` <lgl>,
## #   `1971` <lgl>, `1972` <lgl>, `1973` <lgl>, `1974` <lgl>, `1975` <lgl>,
## #   `1976` <lgl>, `1977` <lgl>, `1978` <lgl>, `1979` <lgl>, `1980` <lgl>,
## #   `1981` <lgl>, `1982` <lgl>, `1983` <lgl>, `1984` <lgl>, `1985` <lgl>,
## #   `1986` <lgl>, `1987` <lgl>, `1988` <lgl>, `1989` <lgl>, `1990` <dbl>,
## #   `1991` <dbl>, `1992` <dbl>, `1993` <dbl>, `1994` <dbl>, `1995` <dbl>, …
gdp_data <- gdp_data |> 
  select(`Country Name`, `Country Code`, `2019`)


gdp_data <- gdp_data |> 
  rename(country_name = `Country Name`,
         country_code = `Country Code`,
         gdp_pc_ppp = `2019`)

gdp_data <- gdp_data |> 
inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))

str(gdp_data)
## tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
##  $ country_name: chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
##  $ country_code: chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
##  $ gdp_pc_ppp  : num [1:28] 64630 60452 27673 46157 47720 ...

We now have 28 observations including the UK.

Rural population

Retrieved from the World Bank (https://data.worldbank.org/indicator/SP.RUR.TOTL.ZS).

Data on the % of population living in rural areas over total population.

rural_data <- read_xls("rural_pop.xls", sheet = 1, range = "A4:BL270")
head(rural_data)
## # A tibble: 6 × 64
##   `Country Name`  `Country Code` `Indicator Name` `Indicator Code` `1960` `1961`
##   <chr>           <chr>          <chr>            <chr>             <dbl>  <dbl>
## 1 Aruba           ABW            Rural populatio… SP.RUR.TOTL.ZS     49.2   49.2
## 2 Africa Eastern… AFE            Rural populatio… SP.RUR.TOTL.ZS     85.4   85.2
## 3 Afghanistan     AFG            Rural populatio… SP.RUR.TOTL.ZS     91.6   91.3
## 4 Africa Western… AFW            Rural populatio… SP.RUR.TOTL.ZS     85.3   84.9
## 5 Angola          AGO            Rural populatio… SP.RUR.TOTL.ZS     89.6   89.2
## 6 Albania         ALB            Rural populatio… SP.RUR.TOTL.ZS     69.3   69.1
## # ℹ 58 more variables: `1962` <dbl>, `1963` <dbl>, `1964` <dbl>, `1965` <dbl>,
## #   `1966` <dbl>, `1967` <dbl>, `1968` <dbl>, `1969` <dbl>, `1970` <dbl>,
## #   `1971` <dbl>, `1972` <dbl>, `1973` <dbl>, `1974` <dbl>, `1975` <dbl>,
## #   `1976` <dbl>, `1977` <dbl>, `1978` <dbl>, `1979` <dbl>, `1980` <dbl>,
## #   `1981` <dbl>, `1982` <dbl>, `1983` <dbl>, `1984` <dbl>, `1985` <dbl>,
## #   `1986` <dbl>, `1987` <dbl>, `1988` <dbl>, `1989` <dbl>, `1990` <dbl>,
## #   `1991` <dbl>, `1992` <dbl>, `1993` <dbl>, `1994` <dbl>, `1995` <dbl>, …
# selecting only the relevant year
rural_data <- rural_data |> 
  select(`Country Name`, `Country Code`, `2019`) |> 
  clean_names() |> 
  rename("rural_pop_percentage" = "x2019")

rural_data <- rural_data |> 
  inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))

str(rural_data)
## tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
##  $ country_name        : chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
##  $ country_code        : chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
##  $ rural_pop_percentage: num [1:28] 41.48 1.96 24.65 33.2 26.08 ...

LGBT rights

Found this LGBT rights index on Our World in Data (https://ourworldindata.org/grapher/lgbt-rights-index) which captures whether LGBT+ people enjoy the same rights as cisgender people combining information on 18 different policies. It includes the legal status of same-sex marriage.

lgbt_rights_index <- read.csv("lgbt-rights-index.csv")

lgbt_rights_index <- lgbt_rights_index |> 
  filter(Year == 2019) |> 
  inner_join(select(codelist, iso3c), by = c("Code" = "iso3c")) |> 
  select(-Year) # all observations are from 2019

str(lgbt_rights_index)
## 'data.frame':    28 obs. of  3 variables:
##  $ Entity            : chr  "Austria" "Belgium" "Bulgaria" "Croatia" ...
##  $ Code              : chr  "AUT" "BEL" "BGR" "HRV" ...
##  $ LGBT..Policy.Index: num  8.92 10 4.94 6.96 3.95 ...

Column names can be renamed:

lgbt_rights_index <- lgbt_rights_index |> 
  rename(country_name = Entity,
         country_code = Code,
         lgbt_policy_index = LGBT..Policy.Index) 

Gender inequality index

Gender Development and Gender Inequality indexes, developed by the United Nations Development. Retrieved from https://hdr.undp.org/data-center/documentation-and-downloads for the year 2019.

gender_index <- read_xlsx("UNDP_gender_indexes.xlsx")

gender_index <- gender_index |>
  select(-dimension, -note, -year) |> # empty/useless columns
  inner_join(select(codelist, iso3c), by = c("countryIsoCode" = "iso3c"))

gender_index |> 
  distinct(country) |> 
  nrow()
## [1] 28
str(gender_index)
## tibble [560 × 7] (S3: tbl_df/tbl/data.frame)
##  $ countryIsoCode: chr [1:560] "AUT" "AUT" "AUT" "AUT" ...
##  $ country       : chr [1:560] "Austria" "Austria" "Austria" "Austria" ...
##  $ indexCode     : chr [1:560] "GII" "GDI" "GDI" "GDI" ...
##  $ index         : chr [1:560] "Gender Inequality Index" "Gender Development Index" "Gender Development Index" "Gender Development Index" ...
##  $ indicatorCode : chr [1:560] "abr" "eys_f" "eys_m" "gdi" ...
##  $ indicator     : chr [1:560] "Adolescent Birth Rate (births per 1,000 women ages 15-19)" "Expected Years of Schooling, female (years)" "Expected Years of Schooling, male (years)" "Gender Development Index (value)" ...
##  $ value         : num [1:560] 5.499 16.451 15.725 0.969 0.053 ...

We checked that we have indeed 28 distinct countries in the dataset.

This dataset collects many indicators apart from the indexes values. We are selecting only the Gender Development and Gender Inequality indexes (GDI and GII):

gender_index <- gender_index |> 
  filter(indicatorCode %in% c("gdi", "gii")) |> 
  select(-c(indexCode, indicatorCode, indicator)) |> # removing redundant columns
  pivot_wider(names_from = index, values_from = value)

colnames(gender_index) <- janitor::make_clean_names(colnames(gender_index)) # cleaning spaces and upper cases

And then exploring them to see which one is a better fit for modeling and predictions:

summary(gender_index$gender_inequality_index)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##  0.0160  0.0555  0.0890  0.1067  0.1335  0.2390
summary(gender_index$gender_development_index)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##  0.9560  0.9725  0.9855  0.9856  0.9918  1.0230
sd(gender_index$gender_inequality_index)
## [1] 0.06664423
sd(gender_index$gender_development_index)
## [1] 0.0167627

We observe that the second one (Gender Development Index) has a very small range, indicating that most countries have nearly identical scores. This is supported by the standard deviation, which shows that the GII is more spread out than the GDI. Being almost constant, GDI won’t add much value to the analysis. This is likely due to the fact that these indexes are created by the United Nations Development Programme for all countries, so it may not capture the finer differences between EU countries.

cor(gender_index$gender_inequality_index, 
    gender_index$gender_development_index, 
    use = "complete.obs")
## [1] 0.1750589

Surprisingly, the two indexes have a very weak positive correlation. While they are not inverse, we interpreted them as measuring opposite things, and had expected a negative correlation. Maybe the correlation coefficient is not useful here because of the low variation of both variables (specially GDI), so ultimately we chose to keep GII and discard GDI.

gender_index <- gender_index |> 
  select(-gender_development_index)

Economist’s Democracy Index

democracy_index <- read_xlsx("EIU_democracy_index.xlsx", sheet = 4)

# the ISO codes were lowercase which impedes the join
democracy_index$geo <- toupper(democracy_index$geo)

# filter for 2019 and EU28 countries
democracy_index <- democracy_index |> 
  filter(time == 2019) |> 
  inner_join((select(codelist, iso3c)), by = c("geo" = "iso3c"))

# clean var names
names(democracy_index) <- names(democracy_index) %>%
  janitor::make_clean_names() %>%
  gsub("_eiu$", "", .)

democracy_index <- democracy_index |> 
  rename(country_code = geo,
         country_name = name,
         year = time)

str(democracy_index)
## tibble [28 × 10] (S3: tbl_df/tbl/data.frame)
##  $ country_code                 : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
##  $ country_name                 : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
##  $ year                         : num [1:28] 2019 2019 2019 2019 2019 ...
##  $ democracy_index              : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...
##  $ electoral_pluralism_index    : num [1:28] 95.8 95.8 91.7 91.7 91.7 95.8 100 95.8 100 95.8 ...
##  $ government_index             : num [1:28] 78.6 82.1 64.3 60.7 64.3 67.9 92.9 78.6 89.3 78.6 ...
##  $ political_participation_index: num [1:28] 83.3 50 72.2 55.6 66.7 66.7 83.3 66.7 88.9 77.8 ...
##  $ political_culture_index      : num [1:28] 68.8 68.8 43.8 50 68.8 68.8 93.8 68.8 87.5 68.8 ...
##  $ civil_liberties_index        : num [1:28] 88.2 85.3 79.4 70.6 88.2 85.3 91.2 85.3 97.1 85.3 ...
##  $ change_in_democracy_index    : num [1:28] 0 -1.4 0 0 0 ...

In this case, we are only keeping the overall index value.

democracy_index <- democracy_index |> 
  select(country_name, country_code, democracy_index)

Joining all country-level data together

country_level_data <- codelist |> 
  select(iso3c, iso2c) |> 
  left_join(gdp_data, by = c("iso3c" = "country_code")) |> 
  # left_join(rural_data, by = c("iso3c" = "country_code")) |> rural population data will probably be discarded
  left_join(gender_index, by = c("iso3c" = "country_iso_code")) |> 
  left_join(lgbt_rights_index, by = c("iso3c" = "country_code")) |> 
  left_join(democracy_index, by = c("iso3c" = "country_code")) |> 
  select(-contains("country_")) # removing all duplicated country_name columns that were joined from each data frame
str(country_level_data)
## tibble [28 × 7] (S3: tbl_df/tbl/data.frame)
##  $ iso3c                  : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
##  $ iso2c                  : chr [1:28] "AT" "BE" "BG" "HR" ...
##  $ gdp_pc_ppp             : num [1:28] 64630 60452 27673 35094 46157 ...
##  $ country                : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
##  $ gender_inequality_index: num [1:28] 0.053 0.048 0.205 0.119 0.235 0.124 0.016 0.092 0.031 0.086 ...
##  $ lgbt_policy_index      : num [1:28] 8.92 10 4.94 6.96 3.95 ...
##  $ democracy_index        : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...

Data cleaning

Selecting relevant variables in the survey data

We are discarding all variables that relate to trade and globalization as deemed not relevant for our analysis qa. We are also discarding variables related to energy policies qb.

We have also not considered questions specifically about Roma ex qc8 and qc14 and qc16


Some of the doubts we had:

AGE

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d11)
ggplot(x_df, aes(x = d11, y = mean)) + geom_point()

As relationship seems pretty linear we are going to use the continuous variable for age and there seems to be a clear group (1to4) which is the same used in the variable with 3 categories left, center and right so we will use the 3-categories variable


POLITICAL OPINIONS

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d1)
ggplot(x_df, aes(x = d1, y = mean)) + geom_point() + xlim(1,10)
## Warning: Removed 2 rows containing missing values or values outside the scale range
## (`geom_point()`).

For political opinions it seems that the relationship is less linear so we will work on the 5 categories cod


MARRIAGE

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d7r1)
ggplot(x_df, aes(x = d7r1, y = mean)) + geom_point() + xlim(1,5)
## Warning: Removed 2 rows containing missing values or values outside the scale range
## (`geom_point()`).

Of all the possible combinations this one seems the best to highlight differences in our target variable


NATIONALITY

There is no easy way to create an immigrant dummy by checking whether someone does not have the nationality of the country in which he is being interviewed for the survey. So we are just going to use q1_29 as a dummy for whether someone owns a non-EU nationality


POLITICAL INTEREST

Using only polintr as a summary of the whole d71 question about how strong is your interest in politics in various domains


EXPERIENCED DISCRIMINATION

For the questions about whether you have experienced discrimination qc2_ I am keeping only qc2_15 which is a binary on whether you have experienced any discrimination or not and I am not keeping the other categories that allowed us to understand if you had experienced discrimination on the basis of a particular motive. We can probably assume that if a person is a part of a specific minority (info from sd2) and is being discriminated is because of being part of that minority (at least in most cases), therefore it felt like information we already had (and which we can easily put in our regression using interaction effects)


PERCIEVED DISCRIMINATION in country

This is a question (qc1) about how widespread you perceived discrimination is in your country. It is a rather peculiar question because it asks individUals for perception at the country level. I think it might be more useful (by aggregating results by country) to use it to build a country level indicator of perceived discrimination against certain minorities that are of our interest rather than use it as an individual level variable. So I will keep them out of the dataset for now

For the same reason I am also discarding qc4 that asks whether in your country you feel like candidates with certain characteristics would be at a disadvantage in the recruitment process. It still basically asks about perceived discrimination at the country level.

And the same reasoning also applies to qc7 which asks if efforts towards reducing discrimination are effective in your country.


HOW DISCRIMINATORY ARE YOU score

I use qc12 and qc13 to build a score from 1 to 10 of how discriminatory are you against certain minorities. I am building the score for each minority and then we can decide later if some are irrelevant.

Note for some categories this score is a bit stupid (ex. voting for whether you would feel uncomfortable if your child was in a love relationship with a old person would give you a high racist score against old people, this is an example of some of the categories for which it is worth excluding the index)

We can also further aggregate to obtain just one score (or obtain religious/ethnic score etc.).

Option also to discard them all (anti lgbtqi sentiment is also captured in the next index built from qc15)

qc6 also asks about discriminatory behaviors, but is about elected public official, it does not ask about a situation that impacts you personally. It also uses different categories for minorities therefore I prefer to use qc12 and qc13 rather than qc6


SUPPORTIVE OF LGBTQ RIGHTS INDEX

Using qc15 we can again build an index for how supportive of lgbtq rights a person is.

I again choose to take the mean across the different answers but we could also use median/mode if we think is better

If we feel each or some answers are particularly useful (given they are closely related with our target variable) we can also use them separately

We could also use qc18 to try to capture anti lgbtq sentiment, but I preferred qc15 as it seemed more straightforward (I therfore deleted qc18, but we can put it back if useful)


MY VOICE COUNTS

I guess that people that feel alienated from society and politics might be less likely to support lgbtq rights so I took the mean of d72 question which asked whether you felt like your voice mattered


OTHERS

qc11 is a strange question feels useless to me, I removed it for now but we can think about it

I also removed qc9 as I don’t really know what to do with it and qc17

data <- data_raw |> 
  select(serialid, # unique identifier
         isocntry, # 2 digit country code
         d11, # age variables
         q1_29, # nationality of interviewee. options given: EU28+Other+DK, using only other = outside of EU
         d70, #life satisfaction
         polintr, # political interest index (summarizes d71 questions)
         starts_with("sd1"), # friends that are minority groups
         starts_with("sd2"), # are you part of a minority
         sd3, # religion
         qc2_15, # experienced discrimination yourself
         qc3, # where discrimination took place
         starts_with("qc5"), # actions against discrimination
         qc10, # how would you report discrimination
         starts_with("qc12"), # feelings about colleagues being minority
         starts_with("qc13"), # feelings about kid being in a relationship with minority
         starts_with("qc15"), # opinions about lgbtqi 
         qc19, # target variable transgender
         qc20, # non-binary genders in documents
         d1r1, # political ideology
         d7r1, # marital status
         d10, # gender binary
         d8, # eduaction 
         d15a_r2, # current occupation (discarded previous occupation d15b)
         d25, # rural vs urban
         d43t, # phones availiabilty
         d60, # financial stress (paying bills)
         netuse, # internet index
         d63, # social class
         starts_with("d72"), # my voice counts
  )

paradata <- data_raw |> 
  select(serialid, # to match it with the other data
         p2, p3, p3r, p4, p5, # paradata)
  )

Removing some of the previously selected variables

sd2_7 to sd2_10: these are possible answer deemed irrelevant to the question about yourself being part of the following minorities: sd2_7 other minorities (I don’t know what other relevant minorities could be there), sd2_8 not part of minorities (can be deducted from the rest), sd2_9 refusal to respond, sd2_10 DK answers sd2t summary binary variable for being part of any minority (we are going to keep the more specific one)

I also remove qc12_nr as I prefer to work on the full variable instead of the recoded version with less categories. Same for qc13 and qc18

data <- data |> 
  # Keep in mind that sd2t does not have NAs so we might want to use that instead of the more specific ones
  select(-c(sd2_7, sd2_8, sd2_9, sd2_10, sd2t)) |> 
  select(-(starts_with("qc12") & ends_with("r"))) |> 
  select(-(starts_with("qc13") & ends_with("r"))) |> 
  select(-(starts_with("qc18") & ends_with("r")))

Check overall data quality

explore_tbl(data)

plot_intro(data)

All columns are numeric columns, the only one which is not is isocntry

data |> 
  select(where(~ !is.numeric(.)))
## # A tibble: 27,438 × 1
##    isocntry
##    <chr>   
##  1 BE      
##  2 BE      
##  3 BE      
##  4 BE      
##  5 BE      
##  6 BE      
##  7 BE      
##  8 BE      
##  9 BE      
## 10 BE      
## # ℹ 27,428 more rows

Most columns do not have explicit NAs

plot_missing(data)

names(which(colSums(is.na(data)) > 0))
## [1] "qc3"

Exploiting the fact that the .dta files has attributes (labels) for all its columns.

If we search for attr(colname, "label") you get back the original long name of the variable

If we instead search for attr(colname, "labels") you get back all the possible encoding levels of the variable (ex.1,2,3,4 etc.) and by doing names(attr(colname, "labels")) you get back the actual meaning of those numbers (ex. 1 = “Yes”, 2 = “No”, etc.)

# Extracting all the full names of the columns
variable_names <- tibble(
  var_code = names(data),
  var_full_name = sapply(data, function(col) attr(col, "label")))
variable_names
## # A tibble: 75 × 2
##    var_code var_full_name                             
##    <chr>    <chr>                                     
##  1 serialid SERIAL CASE ID (PROVIDED BY KANTAR)       
##  2 isocntry COUNTRY CODE - ISO 3166                   
##  3 d11      AGE EXACT                                 
##  4 q1_29    NATIONALITY: OTHER COUNTRIES              
##  5 d70      LIFE SATISFACTION                         
##  6 polintr  POLITICAL INTEREST INDEX (D71 SUMMARIZED) 
##  7 sd1_1    CONTACT: PEOPLE OF DIFFERENT ETHNIC ORIGIN
##  8 sd1_2    CONTACT: PEOPLE OF DIFFERENT SKIN COLOUR  
##  9 sd1_3    CONTACT: ROMA                             
## 10 sd1_4    CONTACT: GAY LESBIAN OR BISEXUAL          
## # ℹ 65 more rows

These long names df might be useful to rename the variables systematically all together. Remember in case we filter out variables after this code chunk and in case we use this df to rename variables that there might be disalignments.

Will now look into the labels for the different levels that our factor variables can take:

attr(data$d70, "labels")
##       Very satisfied     Fairly satisfied   Not very satisfied 
##                    1                    2                    3 
## Not at all satisfied                   DK 
##                    4                    5
names(attr(data$d70, "labels"))
## [1] "Very satisfied"       "Fairly satisfied"     "Not very satisfied"  
## [4] "Not at all satisfied" "DK"
tibble(name_labels = names(attr(data$d70, "labels")),
       labels = attr(data$d70, "labels"))
## # A tibble: 5 × 2
##   name_labels          labels
##   <chr>                 <dbl>
## 1 Very satisfied            1
## 2 Fairly satisfied          2
## 3 Not very satisfied        3
## 4 Not at all satisfied      4
## 5 DK                        5
# Create a list of tibbles containing the labels and their associated name for each variable
list_label_tibbles <- 
  #Applies a function across all columns of a df and returns results as a list
  lapply(names(data), function(col_name) {
    labels <- attr(data[[col_name]], "labels")  # Extract labels
    name_labels <- names(labels)  # Extract label names
    # Create tibble with the extracted data only if labels exist
    if (!is.null(labels)) {
      tibble(name_labels = name_labels, labels = labels)} 
    else {NULL}  # Returns a NULL element for columns without labels
  })

# Giving to each element of the list as name the name of the variable
list_label_tibbles <- setNames(list_label_tibbles, names(data))

# For example
list_label_tibbles$d70
## # A tibble: 5 × 2
##   name_labels          labels
##   <chr>                 <dbl>
## 1 Very satisfied            1
## 2 Fairly satisfied          2
## 3 Not very satisfied        3
## 4 Not at all satisfied      4
## 5 DK                        5

Right column is what appears in our data (as a number). Left column is the label that we must assign to that number when we factorize

Cleaning

Initial cleaning and pre-processing

# Recoding together Germany East and West because we are running analysis at the country level
unique(data$isocntry)
##  [1] "BE"   "DK"   "GR"   "ES"   "FI"   "FR"   "IE"   "IT"   "LU"   "NL"  
## [11] "AT"   "PT"   "SE"   "DE-W" "DE-E" "GB"   "BG"   "CY"   "CZ"   "EE"  
## [21] "HU"   "LV"   "LT"   "MT"   "PL"   "RO"   "SK"   "SI"   "HR"
data <- data |> 
  mutate(isocntry = case_when(
    isocntry %in% c("DE-W", "DE-E") ~ "DE",
    TRUE ~ isocntry))
# We might want to join the full name of the countries using the codelist df

Separating variables for which I can use the attribute labels to factorize them and the variables for which this strategy cannot be used

data <- data |> 
  rename(friends_trans = sd1_7)

non_factor_variables <- c("serialid", "tnscntry", "isocntry", "d11", "q1_29", 
                          names(data)[startsWith(names(data), "sd1_")],
                          names(data)[startsWith(names(data), "sd2_")],
                          names(data)[startsWith(names(data), "qc5_")],
                          names(data)[startsWith(names(data), "qc12_")],
                          names(data)[startsWith(names(data), "qc13_")],
                          names(data)[startsWith(names(data), "qc15_")],
                          names(data)[startsWith(names(data), "d72_")],
                          "d8", "opls")
factor_variables <- setdiff(names(data), non_factor_variables)

Correctly encoding the factor variables that do not need any further cleaning

# Converting them to factors and assign them their labels automatically
data <- data |> 
  mutate(across(all_of(factor_variables), labelled::to_factor))

# Turning DK into NAs for all the factor variables
data <- data |> 
  mutate(across(all_of(factor_variables), ~ fct_na_level_to_value(., extra_levels = "DK")))

# Converting to numeric the variables that should be numeric
# They are already numeric but they carry with them some labels as well that only confuse us, by doing this I remove the labels
data <- data |> 
  mutate(age = as.numeric(d11),
         years_edu = as.numeric(d8)) |> 
  # Recoding correctly d8 education variable according to unique(data_raw$d11))
  mutate(years_edu = case_when(
    years_edu %in% c(0, 99) ~ NA, # Refusal and DK as NAs
    years_edu == 97 ~ 0, # No full time education = 0
    years_edu == 98 ~ age, # still studying = age
    TRUE ~ years_edu)) |> 
  select(-c(d11, d8))

# Converting q1_29 to factor without assigning labels (1 if non-Eu nationality, 0 if EU nationality)
# Same for sd2_
data <- data |> 
  mutate(nonEU_national = as.factor(q1_29),
         across(starts_with("sd2_"), ~ as.factor(.x))) |> 
  select(-q1_29)

Dealing with the other variables on which we do some further pre-processing (feature engineering)

# Creating a variable that counts the number of different minority groups a person has acquaintances with
data <- data |>  
  mutate(across(starts_with("sd1"), ~ if_else(.x == 1, 1, 0))) |> 
  mutate(n_friends_minorities = sd1_1+sd1_2+sd1_3+sd1_4+sd1_5+sd1_6+sd1_8) |> 
  relocate(n_friends_minorities, .before="sd1_1") |> 
  select(-starts_with("sd1"))

# Creating a variable that counts the number of actions against discrimination that you have taken in the last year
data <- data |>  
  mutate(across(starts_with("qc5"), ~ if_else(.x == 1, 1, 0))) |> 
  mutate(n_actions_against_discri = qc5_1+qc5_2+qc5_3+qc5_4) |> 
  relocate(n_actions_against_discri, .after="qc3") |> 
  select(-starts_with("qc5"))
# Building a discriminatory score
data <- data |> 
  # Coding as NAs "it depends" and "DK"
  mutate(across(starts_with("qc12"), ~ if_else(.x >= 12, NA, .x))) |> 
  mutate(across(starts_with("qc13"), ~ if_else(.x >= 12, NA, .x))) |> 
  # Coding as 5 responses = indifferent
  mutate(across(starts_with("qc12"), ~ if_else(.x == 11, 5, .x))) |> 
  mutate(across(starts_with("qc13"), ~ if_else(.x == 11, 5, .x))) |> 
  # Modifying such that higher is more discriminatory
  mutate(roma_discri = 11 - rowMeans(cbind(qc12_1, qc13_1), na.rm = TRUE),
         black_discri = 11 - rowMeans(cbind(qc12_2, qc13_2), na.rm = TRUE),
         asian_discri = 11 - rowMeans(cbind(qc12_3, qc13_3), na.rm = TRUE),
         white_discri = 11 - rowMeans(cbind(qc12_4, qc13_4), na.rm = TRUE),
         jewish_discri = 11 - rowMeans(cbind(qc12_5, qc13_5), na.rm = TRUE),
         muslim_discri = 11 - rowMeans(cbind(qc12_6, qc13_6), na.rm = TRUE),
         buddihst_discri = 11 - rowMeans(cbind(qc12_7, qc13_7), na.rm = TRUE),
         christian_discri = 11 - rowMeans(cbind(qc12_8, qc13_8), na.rm = TRUE),
         atheist_discri = 11 - rowMeans(cbind(qc12_9, qc13_9), na.rm = TRUE),
         lgb_discri = 11 - rowMeans(cbind(qc12_10, qc13_10), na.rm = TRUE),
         trans_discri = 11 - rowMeans(cbind(qc12_11, qc13_11), na.rm = TRUE),
         intersex_discri = 11 - rowMeans(cbind(qc12_12, qc13_12), na.rm = TRUE),
         disability_discri = 11 - rowMeans(cbind(qc12_13, qc13_13), na.rm = TRUE),
         young_discri = 11 - rowMeans(cbind(qc12_14, qc13_14), na.rm = TRUE),
         old_discri = 11 - rowMeans(cbind(qc12_15, qc13_15), na.rm = TRUE)) |> 
  select(-starts_with("qc12")) |> 
  select(-starts_with("qc13"))

# I am deleting the discrimination index against young and old people
# This is because one of the question is: how comfortable you would feel if one of your children was in a love relationship with a person from group x.
# It is totally acceptable that people would not feel comfortable with their kid dating an old person without that accounting for being discriminatory against old people
data <- data |> 
  select(-c("old_discri", "young_discri"))
# Supportive of lbtq rights index
data <- data |> 
  mutate(across(starts_with("qc15"), ~ if_else(.x == 5, NA, .x))) |>
  # Scale of 1 to 4, 1 = supportive, 4 = homophobic
  mutate(antilgbtq_rights = round(rowMeans(cbind(qc15_1, qc15_2, qc15_3), na.rm = TRUE), 2)) |> 
  select(-starts_with("qc15"))
# My voice counts index
data <- data |> 
  mutate(across(starts_with("d72"), ~ if_else(.x > 4, NA, .x))) |>
  mutate(social_alienation = rowMeans(cbind(d72_1, d72_2), na.rm = TRUE)) |> 
  select(-starts_with("d72"))
# The higher the more people think their voice does not matter

This should be our final selection of variables.

We still need to rename them appropriately and check that all the NAs are correctly encoded by looking at the summary.

Rename columns appropriately and move them around to order the dataframe

data <- data |> 
  rename(
    country = isocntry,
    life_sat = d70,
    ethnic_minority = sd2_1,
    skincolor_minority = sd2_2,
    religious_minority = sd2_3,
    roma_minority = sd2_4,
    sexual_minority = sd2_5,
    disability_minority = sd2_6,
    religion = sd3,
    disc = qc2_15,
    disc_where = qc3,
    disc_contact = qc10,
    trans_docs = qc19,
    gender_docs = qc20,
    left_right = d1r1,
    marital_status = d7r1,
    gender = d10,
    occupation = d15a_r2,
    community = d25,
    phone_access = d43t,
    bill_issues = d60,
    internet_use = netuse,
    social_class = d63
  ) 

Now, we will transform the variable disc, which was originally coded in a negative way (1 = “Not mentioned”, 2 = “No, you haven’t been discriminated against”), into a positive dummy variable to make its interpretation more straightforward. The variable is 1 if a person has been subject to discrimination

data <- data |> 
  mutate(suffered_discr = as.factor(ifelse(disc == "Not mentioned", 1, 0))) |> 
  select(-disc) |> 
  relocate(suffered_discr, .before = disc_where)
# Relocating to have a ordered df
data <- data |> 
  relocate(c("age", "gender", "years_edu","community", "marital_status", "occupation", "social_class", "religion", "nonEU_national", "phone_access", "bill_issues", "internet_use"), .after = country) |> 
  relocate(c("left_right", "social_alienation"), .after = polintr) |> 
  relocate(c("friends_trans", "n_friends_minorities", "n_actions_against_discri"), .after = gender_docs)

# Assigning labels to columns which have a difficult meaning
attr(data$gender, "label") <- NULL
attr(data$nonEU_national, "label") <- "OWNS A NON-EU NATIONALITY"
attr(data$social_alienation, "label") <- "HIGHER -> THINK THEIR VOICE DOESN'T  MATTER"
attr(data$ethnic_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$skincolor_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$religious_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$roma_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$sexual_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$suffered_discr, "label") <- "HAVE YOU BEEN SUBJECT TO DISCRIMINATION"
attr(data$n_friends_minorities, "label") <- "YOU KNOW PEOPLE FROM # NUMBER OF DIFFERENT MINORITES"
attr(data$n_actions_against_discri, "label") <- "YOU HAVE DONE # NUMBER OF DIFFERENT ACTIONS TO FIGHT DISCRIMINATIONS"
attr(data$roma_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$black_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$asian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$white_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$jewish_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$muslim_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$buddihst_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$christian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$lgb_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$trans_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$intersex_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$disability_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$antilgbtq_rights, "label") <- "HIGHER -> THEY OPPOSE MORE RIGHTS TO LGBTQ"
summary(data)
##     serialid       country               age          gender     
##  Min.   :    1   Length:27438       Min.   :15.00   Man  :12492  
##  1st Qu.: 6860   Class :character   1st Qu.:37.00   Woman:14946  
##  Median :13720   Mode  :character   Median :53.00                
##  Mean   :13720                      Mean   :51.56                
##  3rd Qu.:20579                      3rd Qu.:66.00                
##  Max.   :27438                      Max.   :98.00                
##                                                                  
##    years_edu                          community    
##  Min.   : 0.00   Rural area or village     : 8776  
##  1st Qu.:17.00   Small or middle sized town:10767  
##  Median :18.00   Large town                : 7881  
##  Mean   :19.66   NA's                      :   14  
##  3rd Qu.:22.00                                     
##  Max.   :90.00                                     
##  NA's   :387                                       
##                                 marital_status 
##  (Re-)Married (1-4 in d7)              :14673  
##  Single living with partner (5-8 in d7): 3321  
##  Single (9-10 in d7)                   : 4314  
##  Divorced or separated (11-12 in d7)   : 2243  
##  Widow (13-14 in d7)                   : 2712  
##  Other (SPONT.)                        :  107  
##  Refusal (SPONT.)                      :   68  
##                                   occupation  
##  Retired (4 in d15a)                   :8791  
##  Manual workers (15 to 18 in d15a)     :5883  
##  Other white collars (13 or 14 in d15a):3536  
##  Managers (10 to 12 in d15a)           :2911  
##  Self-employed (5 to 9 in d15a)        :1979  
##  Students (2 in d15a)                  :1676  
##  (Other)                               :2662  
##                             social_class                       religion    
##  The middle class of society      :13068   Catholic                :11198  
##  The working class of society     : 7233   Orthodox Christian      : 4016  
##  The lower middle class of society: 4070   Non believer or agnostic: 3694  
##  The upper middle class of society: 1889   Protestant              : 3031  
##  None (SPONTANEOUS)               :  229   Atheist                 : 2109  
##  (Other)                          :  389   (Other)                 : 3220  
##  NA's                             :  560   NA's                    :  170  
##  nonEU_national            phone_access               bill_issues   
##  0:27316        Mobile only      :14555   Most of the time  : 2054  
##  1:  122        Landline only    :  802   From time to time : 6538  
##                 Landline & mobile:11576   Almost never/never:18467  
##                 No telephone     :  505   Refusal (SPONT.)  :  379  
##                                                                     
##                                                                     
##                                                                     
##                      internet_use                   life_sat    
##  Everyday/Almost everyday  :19900   Very satisfied      : 7242  
##  Two or three times a week : 1701   Fairly satisfied    :15356  
##  About once a week         :  434   Not very satisfied  : 3736  
##  Two or three times a month:  164   Not at all satisfied: 1002  
##  Less often                :  350   NA's                :  102  
##  Never/No access           : 4311                               
##  No Internet access at all :  578                               
##        polintr               left_right   social_alienation ethnic_minority
##  Strong    : 4644   (1 - 4) Left  :7082   Min.   :1.000     0:26603        
##  Medium    :13701   (5 - 6) Centre:9313   1st Qu.:1.500     1:  835        
##  Low       : 4387   (7 -10) Right :6354   Median :2.000                    
##  Not at all: 4706   DK/Refusal    :4689   Mean   :2.329                    
##                                           3rd Qu.:3.000                    
##                                           Max.   :4.000                    
##                                           NA's   :1000                     
##  skincolor_minority religious_minority roma_minority sexual_minority
##  0:26923            0:26416            0:27001       0:27006        
##  1:  515            1: 1022            1:  437       1:  432        
##                                                                     
##                                                                     
##                                                                     
##                                                                     
##                                                                     
##  disability_minority suffered_discr
##  0:26756             0:23150       
##  1:  682             1: 4288       
##                                    
##                                    
##                                    
##                                    
##                                    
##                                                           disc_where   
##  In a public space                                             :  893  
##  At work                                                       :  788  
##  When looking for a job                                        :  642  
##  At a café, restaurant, bar or nightclub                       :  322  
##  By healthcare personnel (e.g. a receptionist, nurse or doctor):  308  
##  (Other)                                                       : 1054  
##  NA's                                                          :23431  
##                                                                       disc_contact 
##  The police                                                                 :8769  
##  A friend or family member                                                  :5386  
##  An equalities body or ombudsman (SPECIFY THE NAME ACCORDING TO THE COUNTRY):3795  
##  A lawyer                                                                   :2329  
##  Courts                                                                     :1225  
##  (Other)                                                                    :3601  
##  NA's                                                                       :2333  
##  trans_docs   gender_docs                friends_trans   n_friends_minorities
##  Yes :14463   Yes :10856   Yes                  : 2644   Min.   :0.000       
##  No  : 9695   No  :13395   No                   :23520   1st Qu.:1.000       
##  NA's: 3280   NA's: 3187   Refusal (SPONTANEOUS):  306   Median :3.000       
##                            NA's                 :  968   Mean   :3.029       
##                                                          3rd Qu.:5.000       
##                                                          Max.   :7.000       
##                                                                              
##  n_actions_against_discri  roma_discri      black_discri     asian_discri   
##  Min.   :0.0000           Min.   : 1.000   Min.   : 1.000   Min.   : 1.000  
##  1st Qu.:0.0000           1st Qu.: 1.500   1st Qu.: 1.000   1st Qu.: 1.000  
##  Median :0.0000           Median : 4.500   Median : 3.000   Median : 2.500  
##  Mean   :0.3855           Mean   : 4.631   Mean   : 3.579   Mean   : 3.387  
##  3rd Qu.:0.0000           3rd Qu.: 7.000   3rd Qu.: 5.500   3rd Qu.: 5.500  
##  Max.   :4.0000           Max.   :10.000   Max.   :10.000   Max.   :10.000  
##                           NA's   :757      NA's   :542      NA's   :592     
##   white_discri    jewish_discri   muslim_discri    buddihst_discri 
##  Min.   : 1.000   Min.   : 1.00   Min.   : 1.000   Min.   : 1.000  
##  1st Qu.: 1.000   1st Qu.: 1.00   1st Qu.: 1.000   1st Qu.: 1.000  
##  Median : 1.000   Median : 2.00   Median : 4.000   Median : 3.000  
##  Mean   : 1.785   Mean   : 3.18   Mean   : 4.363   Mean   : 3.576  
##  3rd Qu.: 2.000   3rd Qu.: 5.00   3rd Qu.: 6.500   3rd Qu.: 5.500  
##  Max.   :10.000   Max.   :10.00   Max.   :10.000   Max.   :10.000  
##  NA's   :403      NA's   :603     NA's   :662      NA's   :761     
##  christian_discri atheist_discri     lgb_discri      trans_discri   
##  Min.   : 1.000   Min.   : 1.000   Min.   : 1.000   Min.   : 1.000  
##  1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 2.000  
##  Median : 1.000   Median : 1.500   Median : 4.000   Median : 5.000  
##  Mean   : 1.904   Mean   : 2.802   Mean   : 4.399   Mean   : 4.934  
##  3rd Qu.: 2.000   3rd Qu.: 4.000   3rd Qu.: 6.500   3rd Qu.: 7.500  
##  Max.   :10.000   Max.   :10.000   Max.   :10.000   Max.   :10.000  
##  NA's   :414      NA's   :517      NA's   :536      NA's   :1081    
##  intersex_discri  disability_discri antilgbtq_rights
##  Min.   : 1.000   Min.   : 1.000    Min.   :1.000   
##  1st Qu.: 1.500   1st Qu.: 1.000    1st Qu.:1.000   
##  Median : 5.000   Median : 2.500    Median :2.000   
##  Mean   : 4.825   Mean   : 2.977    Mean   :2.147   
##  3rd Qu.: 7.500   3rd Qu.: 4.500    3rd Qu.:3.000   
##  Max.   :10.000   Max.   :10.000    Max.   :4.000   
##  NA's   :1331     NA's   :585       NA's   :791

Our dataset seems quite balanced across the different countries

data |> count(country)
## # A tibble: 28 × 2
##    country     n
##    <chr>   <int>
##  1 AT       1027
##  2 BE       1028
##  3 BG       1032
##  4 CY        503
##  5 CZ       1008
##  6 DE       1537
##  7 DK       1004
##  8 EE       1003
##  9 ES       1005
## 10 FI       1003
## # ℹ 18 more rows

Although some levels of occupation have more observations than others, we have enough observations for each level so we do not need to aggregate over different levels for the variable occupation

data |> count(occupation)
## # A tibble: 8 × 2
##   occupation                                 n
##   <fct>                                  <int>
## 1 Self-employed (5 to 9 in d15a)          1979
## 2 Managers (10 to 12 in d15a)             2911
## 3 Other white collars (13 or 14 in d15a)  3536
## 4 Manual workers (15 to 18 in d15a)       5883
## 5 House persons (1 in d15a)               1358
## 6 Unemployed (3 in d15a)                  1304
## 7 Retired (4 in d15a)                     8791
## 8 Students (2 in d15a)                    1676

Very few people declare themselves to be the higher class of society, nonetheless we keep this level because it makes sense

data |> count(social_class)
## # A tibble: 9 × 2
##   social_class                          n
##   <fct>                             <int>
## 1 The working class of society       7233
## 2 The lower middle class of society  4070
## 3 The middle class of society       13068
## 4 The upper middle class of society  1889
## 5 The higher class of society         157
## 6 Other (SPONTANEOUS)                  59
## 7 None (SPONTANEOUS)                  229
## 8 Refusal (SPONTANEOUS)               173
## 9 <NA>                                560

Given the low number of observations in some categories of the variable religion and the high number of categories we opt to aggregate some of them, otherwise we risk too much noise in our models.

data |> count(religion)
## # A tibble: 16 × 2
##    religion                     n
##    <fct>                    <int>
##  1 Catholic                 11198
##  2 Orthodox Christian        4016
##  3 Protestant                3031
##  4 Other Christian           1183
##  5 Jewish                      58
##  6 Muslim - Shia               77
##  7 Muslim - Sunni             178
##  8 Other Muslim               137
##  9 Sikh                        13
## 10 Buddhist                    58
## 11 Hindu                       32
## 12 Atheist                   2109
## 13 Non believer or agnostic  3694
## 14 Other                     1171
## 15 Refusal (SPONTANEOUS)      313
## 16 <NA>                       170
# Checking if the means of groups we are going to aggregate are similar
data |> 
  mutate(trans_docs=as.numeric(trans_docs)) |> 
  summarise(mean = mean(trans_docs, na.rm=TRUE), .by = religion) |>
  arrange(mean)
## # A tibble: 16 × 2
##    religion                  mean
##    <fct>                    <dbl>
##  1 Sikh                      1.25
##  2 Atheist                   1.27
##  3 Non believer or agnostic  1.28
##  4 Protestant                1.30
##  5 Buddhist                  1.33
##  6 Other                     1.37
##  7 Jewish                    1.38
##  8 Other Christian           1.43
##  9 Catholic                  1.43
## 10 Hindu                     1.44
## 11 Muslim - Shia             1.45
## 12 <NA>                      1.45
## 13 Other Muslim              1.49
## 14 Refusal (SPONTANEOUS)     1.49
## 15 Muslim - Sunni            1.54
## 16 Orthodox Christian        1.58
# We are going to group together atheist with agnostic
# We are also going to put sikh, buddhists, jewish and hindu into the other category
# Finally we are going to group together all muslims
data <- data |> 
  mutate(religion = fct_collapse(religion,
                                "Non-believers" = c("Atheist", "Non believer or agnostic"),
                                "Other" = c("Sikh", "Buddhist", "Jewish", "Hindu", "Other"),
                                "Muslim" = c("Muslim - Shia", "Muslim - Sunni", "Other Muslim")))

#This is what we end up with
data |> count(religion)
## # A tibble: 9 × 2
##   religion                  n
##   <fct>                 <int>
## 1 Catholic              11198
## 2 Orthodox Christian     4016
## 3 Protestant             3031
## 4 Other Christian        1183
## 5 Other                  1332
## 6 Muslim                  392
## 7 Non-believers          5803
## 8 Refusal (SPONTANEOUS)   313
## 9 <NA>                    170

Recoding missing values

Now we will substitute de “Refusal” answers in the remaining variables as NAs. If the respondent refuses to answer it’s equivalent to not knowing his or her answer. We exclude friends_trans because that category could be worth analyzing.

factor_variables <- names(data)[sapply(data, is.factor)]

data <- data %>%
  mutate(across(
    all_of(setdiff(factor_variables, "friends_trans")),  # Exclude "friends_trans"
    ~ {
      # Look for levels that contain "REFUSAL"
      refusal_levels <- grep("REFUSAL", levels(.), value = TRUE, ignore.case = TRUE)
      # If there are levels containing "REFUSAL"
      if (length(refusal_levels) > 0) { 
        # Convert in NA
        fct_recode(., NULL = refusal_levels)  
      } 
      # if not remain without changes
      else {
        .  
      }
    }
  ))

# Mutate NONE level of social class to NA
data <- data %>%
  mutate(social_class = fct_recode(social_class, NULL = "None (SPONTANEOUS)"))

# We turn marital_status level OTHER into NAs, as it is difficult to give it any other meaning. Same for social class
data <- data %>%
  mutate(marital_status = fct_recode(marital_status, NULL = "Other (SPONT.)"),
         social_class = fct_recode(social_class, NULL = "Other (SPONTANEOUS)")) 
plot_intro(data)

plot_missing(data)

The total number of missing observations is quite low (4%) so missing data should not be a huge problem

Given the high percentage of missing values we delete disc_where. This variable was expected to have a high percentage of missingness as it is a question that applies only to people that have been subject to discrimination.

The variable with the second highest number of missing data is left_right, given the importance of this variable it is probably worth to impute those values.

Next there are the variables trans_docs and gender_docs which are respectively our target variable and a closely related variable

Then there is disc_contact which will be deleted as well, given that it does not add meaningful information to our analysis

data <- data |> 
  select(-c("disc_where", "disc_contact"))

Not using paradata for now. We can discuss how to use it

Exploratory Data Analysis

Plotting the distribution of the numeric variables

library(e1071)

# Identify numeric variables
numeric_vars <- names(data)[sapply(data, is.numeric)]

# Creating histogramas y calculating skweness
for (var in numeric_vars) {
  p <- ggplot(data, aes(x = .data[[var]])) +
    geom_histogram(binwidth = 1, fill = "blue", color = "black") +
    labs(title = paste("Histogram of", var), x = var, y = "Count") +
    theme_minimal()
  print(p)
  
  skew <- skewness(data[[var]], na.rm = TRUE)
  cat("Skewness of", var, ":", skew, "\n")
  
  # Suggest transformation if skeness is high
  if (abs(skew) > 1) {
    cat("--> Consider applying a logarithmic transformation to", var, "\n")
  }
}

## Skewness of serialid : 0

## Skewness of age : -0.1189211
## Warning: Removed 387 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of years_edu : 2.379305 
## --> Consider applying a logarithmic transformation to years_edu
## Warning: Removed 1000 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of social_alienation : 0.2702432

## Skewness of n_friends_minorities : -0.04656275

## Skewness of n_actions_against_discri : 2.466341 
## --> Consider applying a logarithmic transformation to n_actions_against_discri
## Warning: Removed 757 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of roma_discri : 0.3302414
## Warning: Removed 542 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of black_discri : 0.8274431
## Warning: Removed 592 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of asian_discri : 0.9145309
## Warning: Removed 403 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of white_discri : 2.363763 
## --> Consider applying a logarithmic transformation to white_discri
## Warning: Removed 603 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of jewish_discri : 1.047646 
## --> Consider applying a logarithmic transformation to jewish_discri
## Warning: Removed 662 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of muslim_discri : 0.4638859
## Warning: Removed 761 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of buddihst_discri : 0.8297239
## Warning: Removed 414 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of christian_discri : 2.142768 
## --> Consider applying a logarithmic transformation to christian_discri
## Warning: Removed 517 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of atheist_discri : 1.316445 
## --> Consider applying a logarithmic transformation to atheist_discri
## Warning: Removed 536 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of lgb_discri : 0.441202
## Warning: Removed 1081 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of trans_discri : 0.2225545
## Warning: Removed 1331 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of intersex_discri : 0.2687168
## Warning: Removed 585 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of disability_discri : 1.054419 
## --> Consider applying a logarithmic transformation to disability_discri
## Warning: Removed 791 rows containing non-finite outside the scale range
## (`stat_bin()`).

## Skewness of antilgbtq_rights : 0.4429458

Analysis of individual-level variables

We must keep in mind our Target variable is qc19 “Do you think that transgender persons should be able to change their civil documents to match their inner gender identity?”

data_percent <- data |> 
  group_by(trans_docs) |> 
  summarise(count = n()) |> 
  mutate(percentage = count / sum(count) * 100)

ggplot(data_percent, aes(x = trans_docs, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity") +  
  geom_text(aes(label = sprintf("%.1f%%", percentage)),  
            vjust = -0.5, size = 4, color = "black") +  
  scale_y_continuous(labels = scales::percent_format(scale = 1)) + 
  labs(
    title = "Overall distribution of support for trans people to change \ntheir gender in civil documents",
    x = "Support for Transgender Rights",
    y = "Percentage"
  ) +
  theme_minimal() +
  theme(legend.position = "none")

Taking a look to our variable of interest alone, we see how the 52.7% of our sample are in favor of trans people to change their gender in their civil documents. However, there is also a significant opposition (35,3%), and a 12% who answered “Don’t know”. We will try to explore this distribution along the variables we consider to be most important for our analysis.

–> When we turned DK into NAs for all the factor variables, we also changed it for qc19 (now trans_docs). We should keep throughout our analysis in mind that NAs for qc19 are actually DK. Later we can code it as DK instead of NAs to have better graphs.

Sociodemographic variables

Gender

data_summary <- data |> 
  count(trans_docs, gender, name = "n") |> 
  group_by(gender) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = gender)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by gender",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within Gender",
    fill = "Gender"
  ) +
  theme_minimal()

# Crear una tabla de contingencia
contingency_table <- table(data$gender, data$trans_docs)

# Realizar la prueba de chi-cuadrado
chisq_test <- chisq.test(contingency_table)
print(chisq_test)
## 
##  Pearson's Chi-squared test with Yates' continuity correction
## 
## data:  contingency_table
## X-squared = 92.715, df = 1, p-value < 2.2e-16

Men exhibit a lower percentage of favorable or dk responses and a higher rate of rejection compared to women. There is a statistically significant association between gender and our target variable, being women more supportive

Age

data |> 
  mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |> 
  drop_na(age_bin) |> # There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
  count(age_bin, trans_docs) |> 
  group_by(age_bin) |> 
  mutate(percentage = n / sum(n) * 100) |>   # Compute percentages
  ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "stack") +
  coord_flip() +  # Horizontal bars
  labs(x = "Age Bins", y = "Percentage", fill = "Trans Docs",
       title = "Stacked Horizontal Bar Plot of Trans Docs by Age Group") +
  theme_minimal()

Younger people seem more likely to support the right for transgender people to have their gender changed on official documents.

We also notice a big increase of NAs for older people, meaning older people are less likely to respond to this question (because of unfamiliarity with the topic maybe)

So how would that distribution look if we get rid of NAs

data |> 
  drop_na(trans_docs) |> 
  mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |> 
  drop_na(age_bin) |> # There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
  count(age_bin, trans_docs) |> 
  group_by(age_bin) |> 
  mutate(percentage = n / sum(n) * 100) |>   # Compute percentages
  ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "stack") +
  coord_flip() +  # Horizontal bars
  labs(x = "Age Bins", y = "Percentage", fill = "Trans Docs",
       title = "Stacked Horizontal Bar Plot of Trans Docs by Age Group") +
  theme_minimal()

We see that differences among age groups are not so evident anymore.

sum(is.na(data$age))
## [1] 0

Religiosity

We have two variables related to religiosity: religion (the religious affiliation professed by the respondent) and religious_minority (whether or not the respondent belongs to a religious minority group).

For the first one it’s better to show a cross table instead of a plot, since there are a lot of categories

CrossTable(data$religion, data$trans_docs,
           digits = 2, 
           expected = FALSE, 
           asresid = TRUE, 
           chisq = TRUE, 
           prop.chisq = FALSE, 
           format = "SPSS")
## 
##    Cell Contents
## |-------------------------|
## |                   Count |
## |             Row Percent |
## |          Column Percent |
## |           Total Percent |
## |           Adj Std Resid |
## |-------------------------|
## 
## Total Observations in Table:  23792 
## 
##                    | data$trans_docs 
##      data$religion |      Yes  |       No  | Row Total | 
## -------------------|-----------|-----------|-----------|
##           Catholic |     5605  |     4241  |     9846  | 
##                    |    56.93% |    43.07% |    41.38% | 
##                    |    39.27% |    44.55% |           | 
##                    |    23.56% |    17.83% |           | 
##                    |    -8.09  |     8.09  |           | 
## -------------------|-----------|-----------|-----------|
## Orthodox Christian |     1421  |     1959  |     3380  | 
##                    |    42.04% |    57.96% |    14.21% | 
##                    |     9.96% |    20.58% |           | 
##                    |     5.97% |     8.23% |           | 
##                    |   -22.99  |    22.99  |           | 
## -------------------|-----------|-----------|-----------|
##         Protestant |     1866  |      807  |     2673  | 
##                    |    69.81% |    30.19% |    11.23% | 
##                    |    13.07% |     8.48% |           | 
##                    |     7.84% |     3.39% |           | 
##                    |    11.00  |   -11.00  |           | 
## -------------------|-----------|-----------|-----------|
##    Other Christian |      597  |      449  |     1046  | 
##                    |    57.07% |    42.93% |     4.40% | 
##                    |     4.18% |     4.72% |           | 
##                    |     2.51% |     1.89% |           | 
##                    |    -1.97  |     1.97  |           | 
## -------------------|-----------|-----------|-----------|
##              Other |      764  |      446  |     1210  | 
##                    |    63.14% |    36.86% |     5.09% | 
##                    |     5.35% |     4.68% |           | 
##                    |     3.21% |     1.87% |           | 
##                    |     2.30  |    -2.30  |           | 
## -------------------|-----------|-----------|-----------|
##             Muslim |      159  |      160  |      319  | 
##                    |    49.84% |    50.16% |     1.34% | 
##                    |     1.11% |     1.68% |           | 
##                    |     0.67% |     0.67% |           | 
##                    |    -3.72  |     3.72  |           | 
## -------------------|-----------|-----------|-----------|
##      Non-believers |     3860  |     1458  |     5318  | 
##                    |    72.58% |    27.42% |    22.35% | 
##                    |    27.05% |    15.32% |           | 
##                    |    16.22% |     6.13% |           | 
##                    |    21.28  |   -21.28  |           | 
## -------------------|-----------|-----------|-----------|
##       Column Total |    14272  |     9520  |    23792  | 
##                    |    59.99% |    40.01% |           | 
## -------------------|-----------|-----------|-----------|
## 
##  
## Statistics for All Table Factors
## 
## 
## Pearson's Chi-squared test 
## ------------------------------------------------------------
## Chi^2 =  973.2956     d.f. =  6     p =  5.330102e-207 
## 
## 
##  
##        Minimum expected frequency: 127.6429

Out of all observations Catholic, non-believers, Orthodox Christians and Protestants sum up to the 81.04% of our sample, being the rest underrepresented.

data_summary <- data |> 
  count(trans_docs, religious_minority, name = "n") |> 
  group_by(religious_minority) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = religious_minority)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by religious minority",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within religious_minority",
    fill = "religious_minority"
  ) +
  theme_minimal()

Ideology

data_summary <- data |> 
  count(trans_docs, left_right, name = "n") |> 
  group_by(left_right) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = left_right)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by ideology",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within ideology",
    fill = "ideology"
  ) +
  theme_minimal()

Stronger left-wing support for trans rights. Right-wing respondents are the most divided, with high opposition levels. Non-responses are highest among those without ideological alignment.

Social class

data_summary <- data |> 
  count(trans_docs, social_class, name = "n") |> 
  group_by(social_class) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = social_class)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by social class",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within social class",
    fill = "social class"
  ) +
  theme_minimal()

Although D63 of the questionnaire measures (oneself’s and one’s household’s) self-perceived social class, it is still a relevant and seemingly divisive variable. We observe a positive correlation, where support grows with increasing (perceived) social class, while explicit lack of support and no response are higher for lower-class individuals.

Education

ggplot(data, aes(x = trans_docs, y = years_edu)) +
  geom_violin() +
  labs(x = "Support for trans people changing their civil documents", y = "Age when stopped full-time education") +
  ggtitle("Distribution of support by education")
## Warning: Removed 387 rows containing non-finite outside the scale range
## (`stat_ydensity()`).

Support doesn’t seem to be related to education.

Area of residence

data_summary <- data |> 
  count(trans_docs, community, name = "n") |> 
  group_by(community) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = community)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by area of residence",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within area of residence",
    fill = "area of residence"
  ) +
  theme_minimal()

Support does not vary much by area of residence.

Other individual-level variables

Having trans friends

data_summary <- data |> 
  count(trans_docs, friends_trans, name = "n") |> 
  group_by(friends_trans) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = friends_trans)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by haivng trans friends",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within groups",
    fill = "Has Trans Friends"
  ) +
  theme_minimal()

Having trans friends is associated with a higher support, while those who refuse to disclose their connections to trans people tend to oppose more.

Country-level EDA

Replication of the plot in Marga’s document. This is probably not needed in the final version of the document.

country_support <- data %>%
  mutate(
    trans_docs = case_when(
      is.na(trans_docs) ~ "DK",
      trans_docs == "Yes" ~ "1",
      trans_docs == "No" ~ "2",
      TRUE ~ as.character(trans_docs)
    )
  ) %>%
  group_by(country, trans_docs = trans_docs) %>%
  summarise(count = n(), .groups = "drop") %>%
  group_by(country) %>%
  mutate(proportion = (count / sum(count))*100) %>%
  ungroup()

ggplot(country_support, aes(x = factor(country, levels = country_support %>%
                                       filter(trans_docs == "1") %>%
                                       arrange(desc(proportion)) %>%
                                       pull(country)), 
                           y = proportion,
                           fill = factor(trans_docs, levels = c("1", "2", "DK")))) +
  geom_bar(stat = "identity", position = position_stack(reverse = TRUE)) +
  scale_fill_manual(values = c("1" = "#497ba9", "2" = "#d56e6e", "DK" = "#9a9595"),
                   name = "",
                   labels = c("Yes", "No", "Don't know")) +
  geom_text(aes(label = round(proportion)), 
          position = position_stack(reverse = TRUE, vjust = 0.5),
          size = 3.5, color = "white") +
  labs(
    title = "QC9: Do you think transgender persons should be able to change their civil documents to match their inner gender identity?",
    x = "", 
    y = ""
  ) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.text.y = element_blank(),
        axis.ticks.y = element_blank(),
        plot.title = element_text(size = 9),
        panel.grid.major.y = element_blank(),
        legend.position = "bottom")

There are some mismatches, I guess the data might have become distorted at some point during processing, but I don’t know when.

trans_docs_prop <- country_support %>%
  filter(trans_docs == "1") %>%
  select(country, proportion) %>%
  rename(trans_support = proportion)

country_long <- country_level_data %>%
  inner_join(trans_docs_prop, by = c("iso2c" = "country")) |> 
  pivot_longer(cols = c(gdp_pc_ppp, gender_inequality_index, lgbt_policy_index, democracy_index),
    names_to = "variable", values_to = "value")

ggplot(country_long, aes(x = value, y = trans_support)) +
  geom_smooth(method = "lm", se = FALSE, color = "lightgray") + # we can remove this
  geom_point(size = 2, color = "blue", alpha = 0.7) +
  geom_text(aes(label = iso3c), vjust = -0.5, hjust = 0.5, size = 3) +
  facet_wrap(~variable, scales = "free_x") +
  labs(
    title = "Relationship between country-level variables and trans support",
    x = "Country-level variable",
    y = "Proportion of Yes answers"
  ) +
  theme_minimal()
## `geom_smooth()` using formula = 'y ~ x'

Democracy and LGBT Policy indeces seem to have a positive linear relationship with the target variable, while Gender Inequality index has a negative linear relationship. The relationship with GDP per capita is non-linear (logarithmic?). There appears to be a “ceiling” of support, beyond which increases in GDP per capita lose effect.

Boxplots for country-level variables:

ggplot(country_long, aes(y = value, x = variable)) +
  geom_boxplot(outlier.color = "red", outlier.shape = 16, fill = "lightblue") +
  coord_flip() +
  theme_minimal() +
  labs(title = "Distribution of country-level variables", x = NULL, y = "value") +
  facet_wrap(~variable, scales = "free") +
  theme(axis.text.y = element_blank(),  
        axis.ticks.x = element_blank())

country_level_data_cor <- country_level_data %>%
  inner_join(trans_docs_prop, by = c("iso2c" = "country"))

cor_matrix <- cor(country_level_data_cor %>%
                    select(gdp_pc_ppp, democracy_index, gender_inequality_index, 
                           lgbt_policy_index, trans_support),
                  use = "complete.obs")

corrplot(cor_matrix, method = "color", type = "upper", 
         addCoef.col = "black", tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

Some heavy correlations which is a little worrying, but as we are going to use these data to build cross-level interactions, this should not compromise the reliability of our analysis too much.

Paradata

# Extracting labels in paradata
list_label_tibbles_paradata <- lapply(names(paradata), function(col_name) {
  labels <- attr(paradata[[col_name]], "labels")  
  name_labels <- names(labels)  
  if (!is.null(labels)) {
    tibble(name_labels = name_labels, labels = labels)
  } else {
    NULL
  }
})

# Asign names to list elements
list_label_tibbles_paradata <- setNames(list_label_tibbles_paradata, names(paradata))

# Convert into factor
paradata <- paradata %>%
  mutate(across(where(~ !is.null(attr(., "labels"))), labelled::to_factor))

# Merging datasets for the analysis
merged_paradata <- merge(data, paradata, by = "serialid", all.x = TRUE)

Number of persons present during interview:

library(gmodels)

# Convert NA in a explicit category
merged_paradata$trans_docs <- as.character(merged_paradata$trans_docs)   
merged_paradata$trans_docs[is.na(merged_paradata$trans_docs)] <- "DK"  
merged_paradata$trans_docs <- as.factor(merged_paradata$trans_docs)  

# CrossTable
CrossTable(merged_paradata$p4, merged_paradata$trans_docs,
           digits=2, 
           expected=F, 
           asresid=T, 
           chisq=TRUE, 
           prop.chisq=F, 
           format="SPSS")
## 
##    Cell Contents
## |-------------------------|
## |                   Count |
## |             Row Percent |
## |          Column Percent |
## |           Total Percent |
## |           Adj Std Resid |
## |-------------------------|
## 
## Total Observations in Table:  27438 
## 
##                                  | merged_paradata$trans_docs 
##               merged_paradata$p4 |       DK  |       No  |      Yes  | Row Total | 
## ---------------------------------|-----------|-----------|-----------|-----------|
## Two (interviewer and respondent) |     2806  |     8146  |    12428  |    23380  | 
##                                  |    12.00% |    34.84% |    53.16% |    85.21% | 
##                                  |    85.55% |    84.02% |    85.93% |           | 
##                                  |    10.23% |    29.69% |    45.29% |           | 
##                                  |     0.58  |    -4.10  |     3.54  |           | 
## ---------------------------------|-----------|-----------|-----------|-----------|
##                            Three |      428  |     1316  |     1758  |     3502  | 
##                                  |    12.22% |    37.58% |    50.20% |    12.76% | 
##                                  |    13.05% |    13.57% |    12.16% |           | 
##                                  |     1.56% |     4.80% |     6.41% |           | 
##                                  |     0.52  |     2.97  |    -3.19  |           | 
## ---------------------------------|-----------|-----------|-----------|-----------|
##                             Four |       36  |      189  |      218  |      443  | 
##                                  |     8.13% |    42.66% |    49.21% |     1.61% | 
##                                  |     1.10% |     1.95% |     1.51% |           | 
##                                  |     0.13% |     0.69% |     0.79% |           | 
##                                  |    -2.50  |     3.25  |    -1.49  |           | 
## ---------------------------------|-----------|-----------|-----------|-----------|
##                     Five or more |       10  |       44  |       59  |      113  | 
##                                  |     8.85% |    38.94% |    52.21% |     0.41% | 
##                                  |     0.30% |     0.45% |     0.41% |           | 
##                                  |     0.04% |     0.16% |     0.22% |           | 
##                                  |    -1.02  |     0.80  |    -0.11  |           | 
## ---------------------------------|-----------|-----------|-----------|-----------|
##                     Column Total |     3280  |     9695  |    14463  |    27438  | 
##                                  |    11.95% |    35.33% |    52.71% |           | 
## ---------------------------------|-----------|-----------|-----------|-----------|
## 
##  
## Statistics for All Table Factors
## 
## 
## Pearson's Chi-squared test 
## ------------------------------------------------------------
## Chi^2 =  26.44717     d.f. =  6     p =  0.0001837381 
## 
## 
##  
##        Minimum expected frequency: 13.50827

The table shows a significant association between the number of people present during the interview and support for transgender people to change their documents

Regarding the duration of the interview we have 2 options p3 and p3r. We will use p3r to have a simpler analysis

# CrossTable
CrossTable(merged_paradata$p3r, merged_paradata$trans_docs,
           digits=2, 
           expected=F, 
           asresid=T, 
           chisq=TRUE, 
           prop.chisq=F, 
           format="SPSS")
## 
##    Cell Contents
## |-------------------------|
## |                   Count |
## |             Row Percent |
## |          Column Percent |
## |           Total Percent |
## |           Adj Std Resid |
## |-------------------------|
## 
## Total Observations in Table:  27438 
## 
##                     | merged_paradata$trans_docs 
## merged_paradata$p3r |       DK  |       No  |      Yes  | Row Total | 
## --------------------|-----------|-----------|-----------|-----------|
##    Up to 14 minutes |       73  |      224  |      260  |      557  | 
##                     |    13.11% |    40.22% |    46.68% |     2.03% | 
##                     |     2.23% |     2.31% |     1.80% |           | 
##                     |     0.27% |     0.82% |     0.95% |           | 
##                     |     0.85  |     2.43  |    -2.88  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##     15 - 29 minutes |      782  |     2284  |     3456  |     6522  | 
##                     |    11.99% |    35.02% |    52.99% |    23.77% | 
##                     |    23.84% |    23.56% |    23.90% |           | 
##                     |     2.85% |     8.32% |    12.60% |           | 
##                     |     0.10  |    -0.61  |     0.52  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##     30 - 44 minutes |     1429  |     4388  |     6305  |    12122  | 
##                     |    11.79% |    36.20% |    52.01% |    44.18% | 
##                     |    43.57% |    45.26% |    43.59% |           | 
##                     |     5.21% |    15.99% |    22.98% |           | 
##                     |    -0.75  |     2.66  |    -2.06  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##     45 - 59 minutes |      703  |     1993  |     3039  |     5735  | 
##                     |    12.26% |    34.75% |    52.99% |    20.90% | 
##                     |    21.43% |    20.56% |    21.01% |           | 
##                     |     2.56% |     7.26% |    11.08% |           | 
##                     |     0.80  |    -1.04  |     0.48  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##     60 - 74 minutes |      202  |      529  |      908  |     1639  | 
##                     |    12.32% |    32.28% |    55.40% |     5.97% | 
##                     |     6.16% |     5.46% |     6.28% |           | 
##                     |     0.74% |     1.93% |     3.31% |           | 
##                     |     0.48  |    -2.67  |     2.25  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##     75 - 89 minutes |       49  |      123  |      276  |      448  | 
##                     |    10.94% |    27.46% |    61.61% |     1.63% | 
##                     |     1.49% |     1.27% |     1.91% |           | 
##                     |     0.18% |     0.45% |     1.01% |           | 
##                     |    -0.67  |    -3.52  |     3.80  |           | 
## --------------------|-----------|-----------|-----------|-----------|
## 90 minutes and more |       42  |      154  |      219  |      415  | 
##                     |    10.12% |    37.11% |    52.77% |     1.51% | 
##                     |     1.28% |     1.59% |     1.51% |           | 
##                     |     0.15% |     0.56% |     0.80% |           | 
##                     |    -1.16  |     0.76  |     0.02  |           | 
## --------------------|-----------|-----------|-----------|-----------|
##        Column Total |     3280  |     9695  |    14463  |    27438  | 
##                     |    11.95% |    35.33% |    52.71% |           | 
## --------------------|-----------|-----------|-----------|-----------|
## 
##  
## Statistics for All Table Factors
## 
## 
## Pearson's Chi-squared test 
## ------------------------------------------------------------
## Chi^2 =  36.84302     d.f. =  12     p =  0.0002368813 
## 
## 
##  
##        Minimum expected frequency: 49.61003

Respondent cooperation

data_summary <- merged_paradata |> 
  count(p5, trans_docs, name = "n") |> 
  group_by(p5) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = p5, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by Respondent cooperation",
    x = "Respondent cooperation",
    y = "Percentage within groups",
    fill = "Support"
  ) +
  theme_minimal()

# Calcular porcentajes
plot_data <- merged_paradata %>%
  group_by(p5, trans_docs) %>%
  summarise(count = n(), .groups = 'drop') %>%
  mutate(percentage = count / sum(count) * 100)

Respondents who engaged better in the survey were more likely to express support.

Correlation and multicollinearity

Now we want to take a look at the possible multicollinearity of our explanatory variables. For it, we calculate the correlation of our numerical variables. As we have too many variables, we visualize just those with a strong correlation to focus on key dependencies.

cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")

corrplot(cor_matrix, method = "color", type = "upper", 
         tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

# Create a matrix where only correlations >= 0.7 are maintained
cor_filtered <- ifelse(abs(cor_matrix) >= 0.7, cor_matrix, NA)

# Graph
corrplot(cor_filtered, method = "color", type = "upper", 
         tl.col = "black", 
         col = colorRampPalette(c("blue", "white", "red"))(200),
         na.label = " ",
         insig = "blank") 

Most strong correlations are among variables related to race, religion or sexual orientation discrimination. Consequently, we are grouping them into 3 new composite variables by averaging related ones, in order to reduce multicollinearity.

# Creating grouped variables
data <- data %>%
  mutate(
    racial_discri = rowMeans(select(., roma_discri, black_discri, asian_discri), na.rm = TRUE), #no white
    sexual_discri = rowMeans(select(., lgb_discri, trans_discri, intersex_discri), na.rm = TRUE),
    religious_discri = rowMeans(select(., jewish_discri, muslim_discri, buddihst_discri), na.rm = TRUE)
  ) 

# Removing original variables to avoid redundancy
data <- data |> 
  select(-c(roma_discri, black_discri, asian_discri, lgb_discri, trans_discri, intersex_discri, jewish_discri, muslim_discri, buddihst_discri))


# Graphical representation
cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")


corrplot(cor_matrix, method = "color", type = "upper", 
         tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

We realize our new variables are still highly correlated between them. For reducing the dimensionality of the dataset even more while preserving information we create one single variable for general minority discrimination.

# Creating grouped variable
data <- data %>%
  mutate(
    minority_discri = rowMeans(select(., racial_discri, sexual_discri, religious_discri, disability_discri), na.rm = TRUE)) 

We decided to exclude white_discri, atheist_discri, christian_discri because we realized they had a median of 1 and a quite small mean, meaning there is almost no reported discrimination against these groups in the dataset.

summary(data$white_discri)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
##   1.000   1.000   1.000   1.785   2.000  10.000     403
summary(data$atheist_discri)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
##   1.000   1.000   1.500   2.802   4.000  10.000     517
summary(data$christian_discri)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
##   1.000   1.000   1.000   1.904   2.000  10.000     414
data <- data |> 
  select(-c(white_discri, atheist_discri, christian_discri, racial_discri, sexual_discri, religious_discri, disability_discri))

Final check of the correlation matrix to confirm that multicollinearity has been reduced.

cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")


corrplot(cor_matrix, method = "color", type = "upper", 
         addCoef.col = "black", tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

Class imbalance

prop.table(table(data$trans_docs, useNA = "ifany"))
## 
##       Yes        No      <NA> 
## 0.5271157 0.3533421 0.1195422
prop.table(table(data$trans_docs, useNA = "no"))
## 
##       Yes        No 
## 0.5986837 0.4013163

Our target variable has a 60/40 distribution so we are not worried about class imbalance.

Less represented classes in other variables have already been aggregated if deemed necessary.

Analysis of missing values

Here we analyse the NA reponses to our target variable. This is a sort of robustness check to understand our data and learn if there are patterns in NA response that we should be worried about e.g. if there are specific demographics of people who are less likely to respond.

Overall the analysis below shows that non response is similar to the descriptive data and aligned with some groups reported “No” to supporting trans_docs in c19. So we’re more at risk of underreporting “no” votes in this survey due to non-response. The correlation is low though so it’s not a major concern.

Who is more likely to not respond to our target?

There are 3,280 NA responses to the target variable. To try understand if the missing values are at random, we will test the correlation between NA response and Use the DK (don’t know) for our target variable.

In the descriptive analysis above, we have already seen in raw terms that NA responses were more frequent from some groups e.g.

  • women,

  • older people,

  • people who also responded NA for political ideology,

  • People who do not have trans friends and those who refused to respond to the friendship question had higher NA responses to the target variable.

  • People with lower survey cooperation

  • By country, we already understand from the challenge description that the NA responses vary. This is a significant disparity.

Create a binary variable for the DK

cntry_name <- codelist |> select(iso2c, country_name = country.name.en)
dk_target <- data |> 
  mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |> 
  left_join(cntry_name, by = join_by(country == iso2c)) |> 
  dplyr::select(-trans_docs, -serialid, -country)

table(dk_target$target_NA)
## 
##     0     1 
## 24158  3280

Confirm DK rates by country. They vary from 1.4% in Belgium to 28.5% in Bulgaria. Overall, the average is 11.95%.

dk_target |> 
  group_by(country_name) |> 
  summarise(count_na = sum(target_NA),
            num_resp = length(country_name),
            pct_na = count_na/num_resp*100) |> 
  ggplot(aes(x=reorder(country_name, -pct_na), y = pct_na))+
  geom_col()+
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.title.x = element_blank()) +
  scale_y_continuous(labels = scales::percent_format(scale = 1)) + 
  labs(y = "Proportion of NA responses")

If all NA responses to the target are removed, this is how much the “Yes” count increases for each of our countries. We see this is not proportional. This is a statistical phenomenon. distribution of the variable looks by country. The NA vote removal, makes our differences in Yes/No differences appear larger.

data |> 
  group_by(country) |> 
  summarise(yes_count = sum(trans_docs == "Yes", na.rm=TRUE),
            num_resp = sum(!is.na(trans_docs)),
            num_na = sum(is.na(trans_docs)),
            pct_yes_withna = yes_count / length(country)*100,
            pct_yes = yes_count/num_resp*100)|> 
  ggplot(aes(x = reorder(country, -pct_yes))) +
  geom_col(aes(y = pct_yes), fill = "red") + # First bar (pct_yes)
  geom_col(aes(y = pct_yes_withna), fill = "yellow", alpha = 0.5) + # Second bar (pct_yes_withna)
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.title.x = element_blank()) +
  scale_y_continuous(labels = scales::percent_format(scale = 1),
                     limits = c(0,100)) + 
  labs(title ="Support for transgender rights to legally change documents, with and without NA's")

Check correlation with DK of target

Run model to test what is correlated with DK response, use Cramers V for association between the factor variables and correlation for the numeric variables in the cleaned data.

  1. Model the data for DK responses against the factor variables.
factor_subset <- dk_target %>%
  dplyr::select(target_NA, where(is.factor)) |> 
  mutate(target_NA = factor(target_NA))

# Run cramers V for factors

target_var <- "target_NA"
factor_variables <- names(factor_subset)
factor_variables <- factor_variables[factor_variables != target_var]

cramers_v_results <- list()

for (variable in factor_variables) {
    contingency_table <- table(factor_subset[[target_var]], 
                               factor_subset[[variable]])
    cramers_v <- CramerV(contingency_table)
    cramers_v_results[[variable]] <- cramers_v
}

# Create a Tibble for Results
cat_results <- tibble(variable = names(cramers_v_results),
       cramers_v = unlist(cramers_v_results)) |> 
  arrange(desc(cramers_v))
cat_results
## # A tibble: 22 × 2
##    variable       cramers_v
##    <chr>              <dbl>
##  1 internet_use      0.136 
##  2 social_class      0.0975
##  3 occupation        0.0852
##  4 marital_status    0.0831
##  5 gender_docs       0.0820
##  6 religion          0.0763
##  7 phone_access      0.0711
##  8 life_sat          0.0642
##  9 polintr           0.0621
## 10 friends_trans     0.0581
## # ℹ 12 more rows

This shows all of the factors have quite low association with the NA responses. The highest being internet use. This is a good sign that the missing values are random.

  1. Look at the numeric variables and test correlations:
numeric_subset <- dk_target %>%
  dplyr::select(target_NA, where(is.numeric)) 

target_var <- "target_NA"
numeric_variables <- names(numeric_subset)[names(numeric_subset) != target_var]

cor_results <- list()

for (variable in numeric_variables) {
    correlation <- cor(numeric_subset$target_NA, 
                       numeric_subset[[variable]],
                       use = "pairwise.complete.obs")
    cor_results[[variable]] <- correlation
}

# Create a Tibble for Results
cor_results <- tibble(variable = names(cor_results),
       cor = unlist(cor_results)) |> 
  arrange(cor)
cor_results
## # A tibble: 7 × 2
##   variable                     cor
##   <chr>                      <dbl>
## 1 n_actions_against_discri -0.0988
## 2 n_friends_minorities     -0.0965
## 3 years_edu                -0.0544
## 4 social_alienation         0.0566
## 5 minority_discri           0.0635
## 6 age                       0.0982
## 7 antilgbtq_rights          0.108

Again, this is not too much cause for concern. We only have around 10% correlations, positive and negative with the target variable.

Modelling relationship with key variables and non-response

Here we run a logistic regression to test for the most important/significant variables. First, we make a subset of data with only our variables that were most correlated in the seciton above (use above +/- 9.5% correlation and above 10% cramers V) and also include gender and country.

cor_results |> filter(cor > 0.09 | cor < -0.9) |> pull(variable)
## [1] "age"              "antilgbtq_rights"
cat_results |> filter(cramers_v >0.1) |> pull(variable)
## [1] "internet_use"

Now model with those variables to see if they are significant in explaining the DK values. Gender will also be included as a key variable.

We run a stepwise AIC on these most correlated variables and then use the best model to test the overall model fit.

# first, run stepwise to determine most important 
# run base model 
dk_fit_null <- glm(target_NA ~ 1,
              data = dk_target, 
              family = "binomial")
# run full fit model of most correlated vars with country (also age^2 for good practice)
dk_fit <- glm(target_NA ~ gender + age + I(age*age) + antilgbtq_rights + internet_use + social_class + country_name, 
              data = dk_target, 
              family = "binomial")

# use stepwise to select best mode l
aic_1 <- MASS::stepAIC(dk_fit, scope = list(upper = dk_fit, 
                             lower = dk_fit_null),
        direction = "both", k = 2, trace=0) # forward based on AIC

# filter vars significant at 5% and calculate exponential
broom::tidy(aic_1) |> 
  filter(p.value<0.05) |> 
  mutate(oddsratio = exp(estimate)) |> 
  select(term, oddsratio, p.value)
## # A tibble: 29 × 3
##    term                                          oddsratio  p.value
##    <chr>                                             <dbl>    <dbl>
##  1 (Intercept)                                      0.0500 8.78e-40
##  2 genderWoman                                      1.20   2.01e- 5
##  3 I(age * age)                                     1.00   4.77e- 4
##  4 antilgbtq_rights                                 1.13   9.69e- 7
##  5 internet_useTwo or three times a week            1.21   2.72e- 2
##  6 internet_useTwo or three times a month           0.307  4.97e- 3
##  7 internet_useNever/No access                      1.28   2.49e- 4
##  8 internet_useNo Internet access at all            1.57   4.62e- 4
##  9 social_classThe lower middle class of society    0.766  4.62e- 5
## 10 social_classThe middle class of society          0.713  4.09e-11
## # ℹ 19 more rows

The best model is the one without age but includes age^2. So we run the full model to keep the lower level variables included.

The model has some interesting findings to who did not respond to our findings. Some things we can see with the odds ratios (excluding interpretation of countries as that is covered above):

  • women are around 20% more likely to give NA responses

  • Anti-lgbti rights people were about 10% more likely to not respond

  • Internet use was significant but is not interpertable. If you had not used the internet (higher NA likelihood) or used it 2-3 times a week (lower NA likelihood) compared to everyday use

  • Social class was significant at all levels, compared to the working class, you were more likely to not respond to our target variable if you reported being in the lower middle, middle or upper middle class. I.e. working class were less likely to answer this question.


Below is an option using undersampling which is probably more legit too.

# split to test and training
na_model <- glm(target_NA ~ .,
                      data = dk_target, 
                      family = "binomial")
summary(na_model)
## 
## Call:
## glm(formula = target_NA ~ ., family = "binomial", data = dk_target)
## 
## Coefficients:
##                                                       Estimate Std. Error
## (Intercept)                                          -5.096435   0.505490
## age                                                   0.012178   0.004217
## genderWoman                                           0.164789   0.082464
## years_edu                                            -0.005912   0.007160
## communitySmall or middle sized town                   0.060070   0.095266
## communityLarge town                                  -0.083705   0.106848
## marital_statusSingle living with partner (5-8 in d7) -0.229059   0.153178
## marital_statusSingle (9-10 in d7)                    -0.151896   0.148656
## marital_statusDivorced or separated (11-12 in d7)     0.289686   0.129040
## marital_statusWidow (13-14 in d7)                     0.216811   0.125780
## occupationManagers (10 to 12 in d15a)                 0.074469   0.188675
## occupationOther white collars (13 or 14 in d15a)     -0.002162   0.186434
## occupationManual workers (15 to 18 in d15a)          -0.087856   0.174101
## occupationHouse persons (1 in d15a)                  -0.244480   0.263347
## occupationUnemployed (3 in d15a)                      0.032945   0.250771
## occupationRetired (4 in d15a)                        -0.152771   0.176731
## occupationStudents (2 in d15a)                       -0.516985   0.364050
## social_classThe lower middle class of society        -0.191067   0.127529
## social_classThe middle class of society              -0.102517   0.102911
## social_classThe upper middle class of society        -0.048871   0.182548
## social_classThe higher class of society               0.028047   0.527417
## religionOrthodox Christian                           -0.272443   0.208576
## religionProtestant                                    0.161109   0.154425
## religionOther Christian                              -0.132124   0.206172
## religionOther                                        -0.791153   0.279671
## religionMuslim                                        0.691685   0.325376
## religionNon-believers                                -0.020914   0.130285
## nonEU_national1                                      -0.370848   1.018180
## phone_accessLandline only                            -0.110733   0.229728
## phone_accessLandline & mobile                         0.039715   0.100780
## phone_accessNo telephone                             -0.500657   0.355297
## bill_issuesFrom time to time                          0.232590   0.188589
## bill_issuesAlmost never/never                         0.457448   0.188085
## internet_useTwo or three times a week                 0.184435   0.156891
## internet_useAbout once a week                         0.437365   0.257105
## internet_useTwo or three times a month               -1.580741   1.011667
## internet_useLess often                                0.079182   0.337876
## internet_useNever/No access                           0.290840   0.128823
## internet_useNo Internet access at all                 0.312489   0.268088
## life_satFairly satisfied                              0.053242   0.101376
## life_satNot very satisfied                            0.291434   0.144484
## life_satNot at all satisfied                          0.005602   0.247800
## polintrMedium                                         0.080670   0.107402
## polintrLow                                            0.126350   0.136224
## polintrNot at all                                    -0.045332   0.151273
## left_right(5 - 6) Centre                              0.122380   0.097494
## left_right(7 -10) Right                               0.094612   0.105449
## social_alienation                                     0.124139   0.048298
## ethnic_minority1                                      0.461184   0.233612
## skincolor_minority1                                  -0.927202   0.522311
## religious_minority1                                  -0.483626   0.269626
## roma_minority1                                       -0.234027   0.404566
## sexual_minority1                                     -0.429264   0.520931
## disability_minority1                                  0.278993   0.250759
## suffered_discr1                                      -0.380922   0.137183
## gender_docsNo                                         0.536267   0.092952
## friends_transNo                                      -0.075223   0.151250
## friends_transRefusal (SPONTANEOUS)                    0.147667   0.397164
## n_friends_minorities                                  0.037060   0.024872
## n_actions_against_discri                             -0.150414   0.064844
## antilgbtq_rights                                      0.055886   0.052789
## minority_discri                                      -0.028983   0.022540
## country_nameBelgium                                  -1.057217   0.426007
## country_nameBulgaria                                  1.258296   0.346358
## country_nameCroatia                                  -0.006931   0.341891
## country_nameCyprus                                    0.618536   0.449668
## country_nameCzechia                                   0.063576   0.328735
## country_nameDenmark                                   0.020749   0.350265
## country_nameEstonia                                   0.498044   0.333545
## country_nameFinland                                   0.506632   0.328111
## country_nameFrance                                    0.209453   0.338444
## country_nameGermany                                   0.551572   0.302573
## country_nameGreece                                    0.155828   0.405321
## country_nameHungary                                  -0.199701   0.337837
## country_nameIreland                                   0.042946   0.348477
## country_nameItaly                                     0.258879   0.342212
## country_nameLatvia                                    0.686826   0.320758
## country_nameLithuania                                 0.118117   0.329320
## country_nameLuxembourg                               -0.023112   0.449294
## country_nameMalta                                    -0.619311   0.644793
## country_nameNetherlands                              -0.325966   0.367757
## country_namePoland                                    0.501405   0.326395
## country_namePortugal                                 -0.339504   0.391052
## country_nameRomania                                  -0.023516   0.400689
## country_nameSlovakia                                  0.249307   0.319901
## country_nameSlovenia                                  0.151497   0.338876
## country_nameSpain                                    -0.389991   0.392042
## country_nameSweden                                    0.821909   0.320433
## country_nameUnited Kingdom                            0.544943   0.329095
##                                                      z value Pr(>|z|)    
## (Intercept)                                          -10.082  < 2e-16 ***
## age                                                    2.888  0.00388 ** 
## genderWoman                                            1.998  0.04568 *  
## years_edu                                             -0.826  0.40898    
## communitySmall or middle sized town                    0.631  0.52833    
## communityLarge town                                   -0.783  0.43339    
## marital_statusSingle living with partner (5-8 in d7)  -1.495  0.13481    
## marital_statusSingle (9-10 in d7)                     -1.022  0.30688    
## marital_statusDivorced or separated (11-12 in d7)      2.245  0.02477 *  
## marital_statusWidow (13-14 in d7)                      1.724  0.08476 .  
## occupationManagers (10 to 12 in d15a)                  0.395  0.69307    
## occupationOther white collars (13 or 14 in d15a)      -0.012  0.99075    
## occupationManual workers (15 to 18 in d15a)           -0.505  0.61382    
## occupationHouse persons (1 in d15a)                   -0.928  0.35322    
## occupationUnemployed (3 in d15a)                       0.131  0.89548    
## occupationRetired (4 in d15a)                         -0.864  0.38736    
## occupationStudents (2 in d15a)                        -1.420  0.15558    
## social_classThe lower middle class of society         -1.498  0.13407    
## social_classThe middle class of society               -0.996  0.31917    
## social_classThe upper middle class of society         -0.268  0.78892    
## social_classThe higher class of society                0.053  0.95759    
## religionOrthodox Christian                            -1.306  0.19148    
## religionProtestant                                     1.043  0.29682    
## religionOther Christian                               -0.641  0.52162    
## religionOther                                         -2.829  0.00467 ** 
## religionMuslim                                         2.126  0.03352 *  
## religionNon-believers                                 -0.161  0.87247    
## nonEU_national1                                       -0.364  0.71569    
## phone_accessLandline only                             -0.482  0.62979    
## phone_accessLandline & mobile                          0.394  0.69353    
## phone_accessNo telephone                              -1.409  0.15880    
## bill_issuesFrom time to time                           1.233  0.21746    
## bill_issuesAlmost never/never                          2.432  0.01501 *  
## internet_useTwo or three times a week                  1.176  0.23977    
## internet_useAbout once a week                          1.701  0.08892 .  
## internet_useTwo or three times a month                -1.563  0.11817    
## internet_useLess often                                 0.234  0.81471    
## internet_useNever/No access                            2.258  0.02397 *  
## internet_useNo Internet access at all                  1.166  0.24377    
## life_satFairly satisfied                               0.525  0.59945    
## life_satNot very satisfied                             2.017  0.04369 *  
## life_satNot at all satisfied                           0.023  0.98196    
## polintrMedium                                          0.751  0.45259    
## polintrLow                                             0.928  0.35366    
## polintrNot at all                                     -0.300  0.76443    
## left_right(5 - 6) Centre                               1.255  0.20939    
## left_right(7 -10) Right                                0.897  0.36960    
## social_alienation                                      2.570  0.01016 *  
## ethnic_minority1                                       1.974  0.04837 *  
## skincolor_minority1                                   -1.775  0.07587 .  
## religious_minority1                                   -1.794  0.07286 .  
## roma_minority1                                        -0.578  0.56295    
## sexual_minority1                                      -0.824  0.40992    
## disability_minority1                                   1.113  0.26588    
## suffered_discr1                                       -2.777  0.00549 ** 
## gender_docsNo                                          5.769 7.96e-09 ***
## friends_transNo                                       -0.497  0.61895    
## friends_transRefusal (SPONTANEOUS)                     0.372  0.71004    
## n_friends_minorities                                   1.490  0.13622    
## n_actions_against_discri                              -2.320  0.02036 *  
## antilgbtq_rights                                       1.059  0.28975    
## minority_discri                                       -1.286  0.19851    
## country_nameBelgium                                   -2.482  0.01308 *  
## country_nameBulgaria                                   3.633  0.00028 ***
## country_nameCroatia                                   -0.020  0.98383    
## country_nameCyprus                                     1.376  0.16896    
## country_nameCzechia                                    0.193  0.84665    
## country_nameDenmark                                    0.059  0.95276    
## country_nameEstonia                                    1.493  0.13539    
## country_nameFinland                                    1.544  0.12257    
## country_nameFrance                                     0.619  0.53600    
## country_nameGermany                                    1.823  0.06831 .  
## country_nameGreece                                     0.384  0.70064    
## country_nameHungary                                   -0.591  0.55444    
## country_nameIreland                                    0.123  0.90192    
## country_nameItaly                                      0.756  0.44936    
## country_nameLatvia                                     2.141  0.03225 *  
## country_nameLithuania                                  0.359  0.71984    
## country_nameLuxembourg                                -0.051  0.95898    
## country_nameMalta                                     -0.960  0.33681    
## country_nameNetherlands                               -0.886  0.37542    
## country_namePoland                                     1.536  0.12449    
## country_namePortugal                                  -0.868  0.38530    
## country_nameRomania                                   -0.059  0.95320    
## country_nameSlovakia                                   0.779  0.43579    
## country_nameSlovenia                                   0.447  0.65483    
## country_nameSpain                                     -0.995  0.31985    
## country_nameSweden                                     2.565  0.01032 *  
## country_nameUnited Kingdom                             1.656  0.09775 .  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## (Dispersion parameter for binomial family taken to be 1)
## 
##     Null deviance: 6149.9  on 18337  degrees of freedom
## Residual deviance: 5702.8  on 18249  degrees of freedom
##   (9100 observations deleted due to missingness)
## AIC: 5880.8
## 
## Number of Fisher Scoring iterations: 7
broom::tidy(na_model)
## # A tibble: 89 × 5
##    term                                    estimate std.error statistic  p.value
##    <chr>                                      <dbl>     <dbl>     <dbl>    <dbl>
##  1 (Intercept)                             -5.10      0.505     -10.1   6.62e-24
##  2 age                                      0.0122    0.00422     2.89  3.88e- 3
##  3 genderWoman                              0.165     0.0825      2.00  4.57e- 2
##  4 years_edu                               -0.00591   0.00716    -0.826 4.09e- 1
##  5 communitySmall or middle sized town      0.0601    0.0953      0.631 5.28e- 1
##  6 communityLarge town                     -0.0837    0.107      -0.783 4.33e- 1
##  7 marital_statusSingle living with partn… -0.229     0.153      -1.50  1.35e- 1
##  8 marital_statusSingle (9-10 in d7)       -0.152     0.149      -1.02  3.07e- 1
##  9 marital_statusDivorced or separated (1…  0.290     0.129       2.24  2.48e- 2
## 10 marital_statusWidow (13-14 in d7)        0.217     0.126       1.72  8.48e- 2
## # ℹ 79 more rows
exp(coefficients(na_model))
##                                          (Intercept) 
##                                          0.006118521 
##                                                  age 
##                                          1.012252085 
##                                          genderWoman 
##                                          1.179144394 
##                                            years_edu 
##                                          0.994105573 
##                  communitySmall or middle sized town 
##                                          1.061910918 
##                                  communityLarge town 
##                                          0.919702513 
## marital_statusSingle living with partner (5-8 in d7) 
##                                          0.795281376 
##                    marital_statusSingle (9-10 in d7) 
##                                          0.859077470 
##    marital_statusDivorced or separated (11-12 in d7) 
##                                          1.336008000 
##                    marital_statusWidow (13-14 in d7) 
##                                          1.242109894 
##                occupationManagers (10 to 12 in d15a) 
##                                          1.077311509 
##     occupationOther white collars (13 or 14 in d15a) 
##                                          0.997840105 
##          occupationManual workers (15 to 18 in d15a) 
##                                          0.915892418 
##                  occupationHouse persons (1 in d15a) 
##                                          0.783111899 
##                     occupationUnemployed (3 in d15a) 
##                                          1.033494121 
##                        occupationRetired (4 in d15a) 
##                                          0.858326624 
##                       occupationStudents (2 in d15a) 
##                                          0.596316021 
##        social_classThe lower middle class of society 
##                                          0.826076903 
##              social_classThe middle class of society 
##                                          0.902562665 
##        social_classThe upper middle class of society 
##                                          0.952304428 
##              social_classThe higher class of society 
##                                          1.028443714 
##                           religionOrthodox Christian 
##                                          0.761516508 
##                                   religionProtestant 
##                                          1.174812676 
##                              religionOther Christian 
##                                          0.876232166 
##                                        religionOther 
##                                          0.453321737 
##                                       religionMuslim 
##                                          1.997077577 
##                                religionNon-believers 
##                                          0.979303553 
##                                      nonEU_national1 
##                                          0.690148654 
##                            phone_accessLandline only 
##                                          0.895177305 
##                        phone_accessLandline & mobile 
##                                          1.040514134 
##                             phone_accessNo telephone 
##                                          0.606132435 
##                         bill_issuesFrom time to time 
##                                          1.261863952 
##                        bill_issuesAlmost never/never 
##                                          1.580036385 
##                internet_useTwo or three times a week 
##                                          1.202538557 
##                        internet_useAbout once a week 
##                                          1.548620752 
##               internet_useTwo or three times a month 
##                                          0.205822438 
##                               internet_useLess often 
##                                          1.082401205 
##                          internet_useNever/No access 
##                                          1.337550906 
##                internet_useNo Internet access at all 
##                                          1.366822298 
##                             life_satFairly satisfied 
##                                          1.054685123 
##                           life_satNot very satisfied 
##                                          1.338345661 
##                         life_satNot at all satisfied 
##                                          1.005618084 
##                                        polintrMedium 
##                                          1.084013516 
##                                           polintrLow 
##                                          1.134678895 
##                                    polintrNot at all 
##                                          0.955679809 
##                             left_right(5 - 6) Centre 
##                                          1.130183275 
##                              left_right(7 -10) Right 
##                                          1.099231740 
##                                    social_alienation 
##                                          1.132173128 
##                                     ethnic_minority1 
##                                          1.585950517 
##                                  skincolor_minority1 
##                                          0.395659376 
##                                  religious_minority1 
##                                          0.616543469 
##                                       roma_minority1 
##                                          0.791340592 
##                                     sexual_minority1 
##                                          0.650987925 
##                                 disability_minority1 
##                                          1.321797816 
##                                      suffered_discr1 
##                                          0.683231382 
##                                        gender_docsNo 
##                                          1.709613372 
##                                      friends_transNo 
##                                          0.927536237 
##                   friends_transRefusal (SPONTANEOUS) 
##                                          1.159127418 
##                                 n_friends_minorities 
##                                          1.037755175 
##                             n_actions_against_discri 
##                                          0.860352034 
##                                     antilgbtq_rights 
##                                          1.057477224 
##                                      minority_discri 
##                                          0.971433339 
##                                  country_nameBelgium 
##                                          0.347421173 
##                                 country_nameBulgaria 
##                                          3.519418325 
##                                  country_nameCroatia 
##                                          0.993092912 
##                                   country_nameCyprus 
##                                          1.856208043 
##                                  country_nameCzechia 
##                                          1.065640125 
##                                  country_nameDenmark 
##                                          1.020965585 
##                                  country_nameEstonia 
##                                          1.645499121 
##                                  country_nameFinland 
##                                          1.659691425 
##                                   country_nameFrance 
##                                          1.233003664 
##                                  country_nameGermany 
##                                          1.735979599 
##                                   country_nameGreece 
##                                          1.168625297 
##                                  country_nameHungary 
##                                          0.818975930 
##                                  country_nameIreland 
##                                          1.043881063 
##                                    country_nameItaly 
##                                          1.295477566 
##                                   country_nameLatvia 
##                                          1.987397162 
##                                country_nameLithuania 
##                                          1.125375345 
##                               country_nameLuxembourg 
##                                          0.977153472 
##                                    country_nameMalta 
##                                          0.538315374 
##                              country_nameNetherlands 
##                                          0.721830044 
##                                   country_namePoland 
##                                          1.651040115 
##                                 country_namePortugal 
##                                          0.712123337 
##                                  country_nameRomania 
##                                          0.976758747 
##                                 country_nameSlovakia 
##                                          1.283136036 
##                                 country_nameSlovenia 
##                                          1.163574636 
##                                    country_nameSpain 
##                                          0.677063226 
##                                   country_nameSweden 
##                                          2.274838960 
##                           country_nameUnited Kingdom 
##                                          1.724509350

Approach to test relationship to DK with splitting and undersampling:

# create new dataset with just vars we want, including age^2
dk_target2 <- dk_target |> 
  select(target_NA, age, antilgbtq_rights, internet_use, social_class, country_name) |> 
  mutate(age_sq = age*age, .after = age)

# to deal with some class imbalance, undersample from the majority group (NA = 0)
set.seed(123)
# Generate an index
index <- createDataPartition(dk_target2$target_NA, p = 0.7, list = FALSE, times = 1)

# Subset the dataframe
train <- dk_target2[index, ]
test <- dk_target2[-index, ]
# check splits 
prop.table(table(train$target_NA))
## 
##         0         1 
## 0.8787421 0.1212579
prop.table(table(test$target_NA))
## 
##         0         1 
## 0.8844612 0.1155388

Now undersample the majority

set.seed(123)
under <- ovun.sample(target_NA~., 
                     data=train, 
                     method = "under", 
                     N = 4000)$data 
    # limit the sample to 4000 obs as we have ~2300 for target minority class. 

table(under$target_NA)
## 
##    0    1 
## 2112 1888
#run the rf model 
rfunder <- randomForest(target_NA~., data=under)
## Warning in randomForest.default(m, y, ...): The response has five or fewer
## unique values.  Are you sure you want to do regression?
rfunder
## 
## Call:
##  randomForest(formula = target_NA ~ ., data = under) 
##                Type of random forest: regression
##                      Number of trees: 500
## No. of variables tried at each split: 2
## 
##           Mean of squared residuals: 0.2389922
##                     % Var explained: 4.1

We see that only around 5% of the variance is explained.

Testing the NA values against paradata

Here we extend the model to see if paradata is related to changed non-response.

para <- paradata |> 
  bind_cols(trans_docs = data$trans_docs,
            age = data$age,
            gender = data$gender,
            country = data$country) |> 
  mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |> 
  select(-serialid, -trans_docs)

summary(para$target_NA)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##  0.0000  0.0000  0.0000  0.1195  0.0000  1.0000
str(para)
## tibble [27,438 × 9] (S3: tbl_df/tbl/data.frame)
##  $ p2       : Factor w/ 6 levels "Before 8 h","8 - 12 h",..: 4 4 3 4 2 4 5 2 4 4 ...
##   ..- attr(*, "label")= chr "TIME OF INTERVIEW"
##  $ p3       : Factor w/ 246 levels "2 minutes","3",..: 44 39 37 30 30 25 26 33 39 39 ...
##   ..- attr(*, "label")= chr "DURATION OF INTERVIEW"
##  $ p3r      : Factor w/ 7 levels "Up to 14 minutes",..: 4 3 3 3 3 2 2 3 3 3 ...
##   ..- attr(*, "label")= chr "DURATION OF INTERVIEW (RECODED)"
##  $ p4       : Factor w/ 5 levels "Two (interviewer and respondent)",..: 1 1 1 1 1 1 1 1 1 1 ...
##   ..- attr(*, "label")= chr "N OF PERSONS PRESENT DURING INTERVIEW"
##  $ p5       : Factor w/ 5 levels "Excellent","Fair",..: 1 1 1 1 1 1 1 1 1 1 ...
##   ..- attr(*, "label")= chr "RESPONDENT COOPERATION"
##  $ age      : num [1:27438] 51 62 38 29 63 41 48 88 44 45 ...
##  $ gender   : Factor w/ 2 levels "Man","Woman": 1 2 2 1 2 2 1 1 2 2 ...
##  $ country  : chr [1:27438] "BE" "BE" "BE" "BE" ...
##  $ target_NA: num [1:27438] 0 0 0 0 0 0 0 0 0 0 ...

First, again test correlation. We use Cramers V since we only have factors:

target_var <- "target_NA"
para_vars <- names(para)[names(para) != target_var]

cramers_v_results <- list()

for (variable in para_vars) {
    contingency_table <- table(para[[target_var]], 
                               para[[variable]])
    contingency_table_no_dk <- contingency_table[, colnames(contingency_table) != "DK"]
    cramers_v <- CramerV(contingency_table_no_dk) 
    # include this for no DK as it is all zero which creates errors
    cramers_v_results[[variable]] <- cramers_v
}


# Create a Tibble for Results
tibble(variable = names(cramers_v_results),
       cramers_v = unlist(cramers_v_results)) |> 
  arrange(desc(cramers_v))
## # A tibble: 8 × 2
##   variable cramers_v
##   <chr>        <dbl>
## 1 country     0.168 
## 2 age         0.123 
## 3 p5          0.106 
## 4 p3          0.0916
## 5 gender      0.0292
## 6 p4          0.0165
## 7 p2          0.0116
## 8 p3r         0.0113

Again, we see low correlation with the paradata and cramers V.

Second, we run another logistic model with just Paradata included.

na_para_model <- glm(target_NA ~ p2 + p3r + p4 + p5 + age + I(age*age) + gender + factor(country), 
                     data = para, 
                     family=binomial(link = "logit"))

broom::tidy(na_para_model) |> 
  filter(p.value<0.05) |> 
  mutate(oddsratio = exp(estimate)) |> 
  select(term, oddsratio, p.value)
## # A tibble: 25 × 3
##    term              oddsratio  p.value
##    <chr>                 <dbl>    <dbl>
##  1 (Intercept)          0.0439 4.65e-12
##  2 p4Four               0.694  4.20e- 2
##  3 p5Fair               1.42   2.05e-15
##  4 p5Average            1.74   8.91e-18
##  5 p5Bad                3.49   2.14e-22
##  6 age                  0.983  2.85e- 3
##  7 I(age * age)         1.00   3.43e- 9
##  8 genderWoman          1.14   1.07e- 3
##  9 factor(country)BE    0.179  6.77e- 9
## 10 factor(country)BG    5.30   2.16e-31
## # ℹ 15 more rows

We see that when controlling for age, gender and country, the survey cooperation variable is significant.

When compared to those with an excellent cooperation rating, people were more likely to respond. This increases with lacking cooperation. If cooperation was fair, there was around 40% more chance of NA, if cooperation was average, around 75% higher chance of NA. If cooperation was bad, there was about 350% higher chance of a NA response to our target variable.

Overall, the correlations with our target variables are low which means we don’t have a major concern. Some are interesting e.g. interview cooperation. The worse the cooperation, the more likely to not respond to the question. This could be underreporting No votes, because as we saw in the descriptive analysis, the worse the cooperation, the higher the No vote for supporting trans_docs. There could also be some reverse causality, as not responding leads to a worse cooperation score. But the odds ratios here are very high.

Imputing missing data

As we have different types of variables we decide to go with the default methods. Selecting the best method for each type of variable would be too computationally intensive

# Excluding target variable and other useless variables
imputation_data <- data |> 
  select(-c(serialid, country, trans_docs))

# Running it with the default methods
imputed_data <- mice(imputation_data, m = 1, seed=1234)
## 
##  iter imp variable
##   1   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
##   2   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
##   3   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
##   4   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
##   5   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
# By default: numerical variables -> pmm, binary factors -> logreg, > 2 levels factors -> polyreg
imputed_data$method
##                      age                   gender                years_edu 
##                       ""                       ""                    "pmm" 
##                community           marital_status               occupation 
##                "polyreg"                "polyreg"                       "" 
##             social_class                 religion           nonEU_national 
##                "polyreg"                "polyreg"                       "" 
##             phone_access              bill_issues             internet_use 
##                       ""                "polyreg"                       "" 
##                 life_sat                  polintr               left_right 
##                "polyreg"                       ""                "polyreg" 
##        social_alienation          ethnic_minority       skincolor_minority 
##                    "pmm"                       ""                       "" 
##       religious_minority            roma_minority          sexual_minority 
##                       ""                       ""                       "" 
##      disability_minority           suffered_discr              gender_docs 
##                       ""                       ""                 "logreg" 
##            friends_trans     n_friends_minorities n_actions_against_discri 
##                "polyreg"                       ""                       "" 
##         antilgbtq_rights          minority_discri 
##                    "pmm"                    "pmm"
final_data <- complete(imputed_data)

colSums(is.na(imputation_data))
##                      age                   gender                years_edu 
##                        0                        0                      387 
##                community           marital_status               occupation 
##                       14                      175                        0 
##             social_class                 religion           nonEU_national 
##                     1021                      483                        0 
##             phone_access              bill_issues             internet_use 
##                        0                      379                        0 
##                 life_sat                  polintr               left_right 
##                      102                        0                     4689 
##        social_alienation          ethnic_minority       skincolor_minority 
##                     1000                        0                        0 
##       religious_minority            roma_minority          sexual_minority 
##                        0                        0                        0 
##      disability_minority           suffered_discr              gender_docs 
##                        0                        0                     3187 
##            friends_trans     n_friends_minorities n_actions_against_discri 
##                      968                        0                        0 
##         antilgbtq_rights          minority_discri 
##                      791                      355
colSums(is.na(final_data))
##                      age                   gender                years_edu 
##                        0                        0                        0 
##                community           marital_status               occupation 
##                        0                        0                        0 
##             social_class                 religion           nonEU_national 
##                        0                        0                        0 
##             phone_access              bill_issues             internet_use 
##                        0                        0                        0 
##                 life_sat                  polintr               left_right 
##                        0                        0                        0 
##        social_alienation          ethnic_minority       skincolor_minority 
##                        0                        0                        0 
##       religious_minority            roma_minority          sexual_minority 
##                        0                        0                        0 
##      disability_minority           suffered_discr              gender_docs 
##                        0                        0                        0 
##            friends_trans     n_friends_minorities n_actions_against_discri 
##                        0                        0                        0 
##         antilgbtq_rights          minority_discri 
##                        0                        0
final_data <- final_data |> 
  cbind(data$trans_docs) |> 
  cbind(data$country) |>
  rename("trans_docs" = "data$trans_docs",
         "country" = "data$country") |> 
  relocate(country, .before = everything())

We know that it would be better to impute multiple datasets and then pool the results of different regressions on those different datasets together, but running more than one multilevel regression would be too computationally intensive and so we are not able to do this.

Joining together all our data

country_level_data stores all our data defined at the country level.

final_data stores all our data (after imputation) for individual level variables.

complete_df <- final_data |> 
  left_join(country_level_data, 
            by = join_by(country == iso2c)) |> 
  select(-c(country.y, iso3c))

Explanatory model

To be finished…

  1. Run logistic with all variables and extract only the significant variables

  2. Confirm this is similar to the results we obtain using stepwise regression/lasso regularization

  3. Based on 1 & 2 decide which individual level variables to include in the mixed model

  4. Build the mixed model (look at the mixed model section for further details on how this needs to be built)

Simple logistic regression

I am using only individual level data for now. This is a simple model to see at the global level i.e. no country level control, which variables are significant. The numeric data has also been scaled.

datalr <- final_data |> 
  # Dropping NAs (there should be NAs only in our target variable)
  drop_na() |> 
  # Selecting only predictor variables
  select(-"country") |> 
  # Scale variables 
  mutate(across(where(is.numeric), scale)) |> 
  # Transforming target to binary numeric Yes=1, No=0
  mutate(trans_docs = as.numeric(trans_docs == "Yes"))
  
# now run the full model
simple_logistic <- glm(trans_docs ~ ., data = datalr, family = binomial(link = "logit"))

# Save the summary
logistic_summary <- summary(simple_logistic)

# create a tibble to more easily search through significant variables
logistic_results <- tibble(
  broom::tidy(simple_logistic) |>
    filter(p.value<0.05) |>
    mutate(oddsratio = exp(estimate)) |>
    select(term, estimate, oddsratio, p.value) |> 
    arrange(oddsratio))
logistic_results
## # A tibble: 26 × 4
##    term                                  estimate oddsratio   p.value
##    <chr>                                    <dbl>     <dbl>     <dbl>
##  1 gender_docsNo                           -2.66     0.0697 0        
##  2 friends_transRefusal (SPONTANEOUS)      -0.798    0.450  2.05e-  5
##  3 antilgbtq_rights                        -0.699    0.497  1.16e-194
##  4 roma_minority1                          -0.568    0.567  1.43e-  4
##  5 internet_useTwo or three times a week   -0.418    0.658  4.29e-  8
##  6 life_satNot at all satisfied            -0.395    0.673  3.56e-  4
##  7 internet_useNever/No access             -0.348    0.706  1.92e-  7
##  8 bill_issuesFrom time to time            -0.335    0.716  8.36e-  6
##  9 internet_useAbout once a week           -0.332    0.718  2.13e-  2
## 10 occupationRetired (4 in d15a)           -0.321    0.725  1.24e-  4
## # ℹ 16 more rows
Interpeting results

To interpret the coefficients as odds ratios, anything above 1 indicates they are more likely to support the changes to civil documents for trans people.

The logistic regression shows that 26 statistically significant terms. This includes factors variables with multiple terms. Of our 29 scaled variables, the significant variables (at the 5% level) are:

More likely to OPPPOSE the right to change civil documents for trans people, include:
- men (compared to wom) - younger people - people who oppose legal rights to add a third-gender in official docs (compared to those who do) - people who refused to answer whether they have trans friends (compared to those who do) - people who are more financially sound (have fewer bill issues) - people not satisfied with their life (compared to those who are ‘very satisfied’) - people who identified as roma or an ethnic minority - people who are more discriminatory against minorities

More likely to SUPPORT the the right - older people - women - people who were self-employed (compared to all other occupation types incl students) - unmarried (single) people - non-believers (religious) - people with a landline and mobile - people who use the internet everyday/almost everyday (compared to all other internet use categories) - people who reported being more left wing (compared to right wing) - people who had friends in minority groups.


NUMERIC VARIABLES

Without scaling, we interpret logistic regression output as:

coef(simple_logistic): these coefficients represent the change in the log-odds for a one-unit increase in the corresponding independent variable

exp(coef(simple_logistic)): the exponential of the slope coefficient (exp(B)) tells us the change of the odds if the independent variable increases by one unit

If the data is scaled:

A coefficient B (from a logistic regression) now reflects the change in the log-odds for a one standard deviation increase in the predictor variable, rather than a one-unit increase in the original scale.

The odds ratio (exp(B)) now tells you how the odds change with a one standard deviation increase in the predictor variable, rather than a one-unit increase.

Here we compare the pre and post transformation of coefficients for interpretation:

# all the coefficients
head(coef(simple_logistic))
##                         (Intercept)                                 age 
##                          2.69303178                          0.20879798 
##                         genderWoman                           years_edu 
##                          0.26342657                         -0.01215087 
## communitySmall or middle sized town                 communityLarge town 
##                          0.01810837                         -0.04039684
# for their interpretation
head(exp(coef(simple_logistic)))
##                         (Intercept)                                 age 
##                          14.7764069                           1.2321960 
##                         genderWoman                           years_edu 
##                           1.3013817                           0.9879227 
## communitySmall or middle sized town                 communityLarge town 
##                           1.0182733                           0.9604082

FACTOR VARIABLES

Factor variables when exponentialised give the likelihood to respond no/yes relative to the base group in the factor variable. We use the function factors to view the levels and identify the base group.

To assist with interpretation of factor outputs:

Here is a function to identify all the base levels in each factor group. Useful to refer to during analysis of different logistic models.

extract_base_groups <- function(df) {

  # extract factor vars only and list to print values
  factor_vars <- names(final_data)[sapply(final_data, is.factor)]
  base_groups <- list()
  
  # loop through values to check all levels
  for (var in factor_vars) {
    if (length(levels(df[[var]])) > 0) { # Check step - should be TRUE for all selected. 
      contrast_matrix <- contrasts(df[[var]])
      if (is.null(contrast_matrix)) {
        base_groups[[var]] <- levels(df[[var]])[1] # check only - shouldn't ever run
      } else {
        base_group_level <- levels(df[[var]])[rowSums(abs(contrast_matrix)) == 0] # base group is the one with all zeroes, so we extract that
        base_groups[[var]] <- base_group_level
      }
    } else {
      base_groups[[var]] <- NA # Indicate non-factor or factor with no levels.
    }
  }
  return(base_groups)
}

# run function with 'final data' and print a tidy output
factor_bases <- extract_base_groups(final_data)

factor_bases <- as_tibble(factor_bases) |> 
  pivot_longer(cols = everything(), 
               names_to = "vars",
               values_to = "base_group")

factor_bases
## # A tibble: 23 × 2
##    vars           base_group                    
##    <chr>          <chr>                         
##  1 gender         Man                           
##  2 community      Rural area or village         
##  3 marital_status (Re-)Married (1-4 in d7)      
##  4 occupation     Self-employed (5 to 9 in d15a)
##  5 social_class   The working class of society  
##  6 religion       Catholic                      
##  7 nonEU_national 0                             
##  8 phone_access   Mobile only                   
##  9 bill_issues    Most of the time              
## 10 internet_use   Everyday/Almost everyday      
## # ℹ 13 more rows
Model performance - Simple logistic

Here, we test the models ability to classify people as supporting or not supporting the rights.

# AIC of model
simple_logistic$aic
## [1] 19544.18
#predicted probabilities of being a 1 (i.e. a refusal of possibility of trans doc)
predicted_probs <- simple_logistic$fitted.values
# same by running
# predicted_probs <- predict(simple_logistic, type = "response")
head(predicted_probs)
##         1         2         3         4         5         6 
## 0.3463520 0.4321645 0.5170989 0.5799662 0.9141149 0.5131253
# Turning them to classes using custom threshold
predicted_classes <- ifelse(predicted_probs > 0.5, 1, 0)
head(predicted_classes)
## 1 2 3 4 5 6 
## 0 0 1 1 1 1

Get the confusion matrix:

confusionMatrix(as.factor(datalr$trans_docs), as.factor(predicted_classes))
## Confusion Matrix and Statistics
## 
##           Reference
## Prediction     0     1
##          0  7608  2087
##          1  2246 12217
##                                           
##                Accuracy : 0.8206          
##                  95% CI : (0.8157, 0.8255)
##     No Information Rate : 0.5921          
##     P-Value [Acc > NIR] : < 2e-16         
##                                           
##                   Kappa : 0.6277          
##                                           
##  Mcnemar's Test P-Value : 0.01638         
##                                           
##             Sensitivity : 0.7721          
##             Specificity : 0.8541          
##          Pos Pred Value : 0.7847          
##          Neg Pred Value : 0.8447          
##              Prevalence : 0.4079          
##          Detection Rate : 0.3149          
##    Detection Prevalence : 0.4013          
##       Balanced Accuracy : 0.8131          
##                                           
##        'Positive' Class : 0               
## 

The simple model predicted people’s response with 82% accuracy. That is quite decent for a basic first model. This shows the response is quite explainable with the data we have. The model is slightly better at predicting those who do not support than those who do. Seen by higher specificity than sensitivity (85% vs 77%). But they are both comparable which is good and confirms we don’t have great class imbalance.

roc_obj <- roc(datalr$trans_docs, predicted_probs)
## Setting levels: control = 0, case = 1
## Setting direction: controls < cases
# Terrible graphs, do we have better ones? Not sure. I think the first is good enough. 
pROC::ggroc(roc_obj)

plot(roc_obj)

coords(roc_obj, "best")
##   threshold specificity sensitivity
## 1 0.5937607    0.843115   0.7938187
auc(datalr$trans_docs, predicted_probs)
## Setting levels: control = 0, case = 1
## Setting direction: controls < cases
## Area under the curve: 0.8937

Stepwise regression

Chooses the best simple logistic model based on the lowest AIC achievable

set.seed(123)
stepAIC <- step(simple_logistic, direction = "both", trace=0)
stepAIC
## 
## Call:  glm(formula = trans_docs ~ age + gender + marital_status + occupation + 
##     religion + phone_access + bill_issues + internet_use + life_sat + 
##     left_right + ethnic_minority + roma_minority + suffered_discr + 
##     gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri + 
##     antilgbtq_rights + minority_discri, family = binomial(link = "logit"), 
##     data = datalr)
## 
## Coefficients:
##                                          (Intercept)  
##                                              2.62467  
##                                                  age  
##                                              0.20698  
##                                          genderWoman  
##                                              0.26440  
## marital_statusSingle living with partner (5-8 in d7)  
##                                              0.04042  
##                    marital_statusSingle (9-10 in d7)  
##                                              0.13987  
##    marital_statusDivorced or separated (11-12 in d7)  
##                                              0.10517  
##                    marital_statusWidow (13-14 in d7)  
##                                             -0.10979  
##                occupationManagers (10 to 12 in d15a)  
##                                              0.01744  
##     occupationOther white collars (13 or 14 in d15a)  
##                                             -0.25937  
##          occupationManual workers (15 to 18 in d15a)  
##                                             -0.14375  
##                  occupationHouse persons (1 in d15a)  
##                                              0.05889  
##                     occupationUnemployed (3 in d15a)  
##                                             -0.12589  
##                        occupationRetired (4 in d15a)  
##                                             -0.30665  
##                       occupationStudents (2 in d15a)  
##                                             -0.29364  
##                           religionOrthodox Christian  
##                                             -0.12432  
##                                   religionProtestant  
##                                              0.08546  
##                              religionOther Christian  
##                                             -0.13836  
##                                        religionOther  
##                                              0.06244  
##                                       religionMuslim  
##                                             -0.24374  
##                                religionNon-believers  
##                                              0.13104  
##                            phone_accessLandline only  
##                                             -0.09735  
##                        phone_accessLandline & mobile  
##                                              0.27311  
##                             phone_accessNo telephone  
##                                             -0.19336  
##                         bill_issuesFrom time to time  
##                                             -0.34079  
##                        bill_issuesAlmost never/never  
##                                             -0.22203  
##                internet_useTwo or three times a week  
##                                             -0.41597  
##                        internet_useAbout once a week  
##                                             -0.31328  
##               internet_useTwo or three times a month  
##                                             -0.09201  
##                               internet_useLess often  
##                                              0.02229  
##                          internet_useNever/No access  
##                                             -0.33028  
##                internet_useNo Internet access at all  
##                                             -0.02332  
##                             life_satFairly satisfied  
##                                              0.05142  
##                           life_satNot very satisfied  
##                                             -0.14512  
##                         life_satNot at all satisfied  
##                                             -0.38741  
##                             left_right(5 - 6) Centre  
##                                              0.05631  
##                              left_right(7 -10) Right  
##                                             -0.17298  
##                                     ethnic_minority1  
##                                             -0.26298  
##                                       roma_minority1  
##                                             -0.58673  
##                                      suffered_discr1  
##                                             -0.22381  
##                                        gender_docsNo  
##                                             -2.65983  
##                                      friends_transNo  
##                                             -0.13252  
##                   friends_transRefusal (SPONTANEOUS)  
##                                             -0.79810  
##                                 n_friends_minorities  
##                                              0.15912  
##                             n_actions_against_discri  
##                                              0.03980  
##                                     antilgbtq_rights  
##                                             -0.69753  
##                                      minority_discri  
##                                             -0.23593  
## 
## Degrees of Freedom: 24157 Total (i.e. Null);  24112 Residual
## Null Deviance:       32540 
## Residual Deviance: 19430     AIC: 19530

The stepwise regression has 19 of the 29 variables included in it’s best model. It is quite consistent with what our significant variables were above, so we will not provide further commentary. Compared to the full model, this reduced model does not provide a statistically significant improvement in fit. But it does give us a more simple model and shows us what individual level variable may be most important overall.

anova(simple_logistic, stepAIC)
## Analysis of Deviance Table
## 
## Model 1: trans_docs ~ age + gender + years_edu + community + marital_status + 
##     occupation + social_class + religion + nonEU_national + phone_access + 
##     bill_issues + internet_use + life_sat + polintr + left_right + 
##     social_alienation + ethnic_minority + skincolor_minority + 
##     religious_minority + roma_minority + sexual_minority + disability_minority + 
##     suffered_discr + gender_docs + friends_trans + n_friends_minorities + 
##     n_actions_against_discri + antilgbtq_rights + minority_discri
## Model 2: trans_docs ~ age + gender + marital_status + occupation + religion + 
##     phone_access + bill_issues + internet_use + life_sat + left_right + 
##     ethnic_minority + roma_minority + suffered_discr + gender_docs + 
##     friends_trans + n_friends_minorities + n_actions_against_discri + 
##     antilgbtq_rights + minority_discri
##   Resid. Df Resid. Dev  Df Deviance Pr(>Chi)
## 1     24096      19420                      
## 2     24112      19434 -16  -14.121   0.5897

DIEGO: ask for an explanation of this

Lasso regularization

We still have too many variables for a mixed model. So here we will use Lasso to keep only our most important variables for the mixed models.

Without this step, the glmer stage is too computationally expensive.

lasso_data <- final_data |> 
  # Doing same preprocessing as done for simple logistic
  drop_na() |> 
  select(-"country") |> 
  mutate(across(where(is.numeric), scale)) |> 
  mutate(trans_docs = as.numeric(trans_docs == "Yes")) 

# Dummifying all levels to see whether some levels are particularly important
lasso_data <- lasso_data %>% 
  dummy_cols(select_columns = names(.)[sapply(., is.factor)],
             remove_selected_columns = TRUE,
             remove_first_dummy = TRUE)
  

# Convert data into a matrix for glmnet
x_lasso <- lasso_data |> select(-trans_docs) |> as.matrix() 
y_lasso <- lasso_data |> select(trans_docs) |> as.matrix()

set.seed(123)

# Define lamdas
lambda_seq <- 10^seq(-2, -5, length.out = 100)

# Fit the Lasso model (alpha = 1 for Lasso regularization)
lasso_model <- cv.glmnet(x_lasso, y_lasso, family = "binomial", alpha = 1, lambda = lambda_seq)

lasso_model$lambda.1se # The largest lambda within one standard error of lambda.min. This results in a simpler model with fewer selected features.
## [1] 0.007564633
lasso_model$lambda.min
## [1] 0.0006579332
# Get all the coefficients
coefficients <- coef(lasso_model, s = "lambda.1se")
# Filter for the non-zero ones
non_zero_features <- rownames(coefficients)[which(coefficients != 0)]
non_zero_features
##  [1] "(Intercept)"                           
##  [2] "age"                                   
##  [3] "n_friends_minorities"                  
##  [4] "antilgbtq_rights"                      
##  [5] "minority_discri"                       
##  [6] "gender_Woman"                          
##  [7] "occupation_Managers (10 to 12 in d15a)"
##  [8] "religion_Orthodox Christian"           
##  [9] "phone_access_Landline & mobile"        
## [10] "bill_issues_From time to time"         
## [11] "internet_use_Two or three times a week"
## [12] "internet_use_Never/No access"          
## [13] "life_sat_Not very satisfied"           
## [14] "life_sat_Not at all satisfied"         
## [15] "left_right_(7 -10) Right"              
## [16] "ethnic_minority_1"                     
## [17] "roma_minority_1"                       
## [18] "suffered_discr_1"                      
## [19] "gender_docs_No"                        
## [20] "friends_trans_Refusal (SPONTANEOUS)"

Lasso includes variables similar to what was suggested by our initial logistic regression and the subsequent stepwise.

In particular we can see again that:

  1. age is relevant

  2. gender is relevant

  3. It matters whether you have friends that belong to minorites (n_friends_minorities)

Also `ant

Final variable selection

From these hints above and general intuition, we will select the following variables as our individual level fixed effects in the mixed level model:

  • age
  • gender
  • religion (to be recoded as non-believer dummy since that’s the significant variable)
  • bill_issues
  • internet use (recoded to everyday or not)
  • left_right
  • ethnic minority + roma minority (recoded to one dummy)
  • trans_friends
  • lgbti_docs
  • minority_discri

And these are our pre-defined fixed

Mixed model

Random Intercept Model:

Allows the baseline level (intercept) to vary across groups. Assumes the relationship between predictors and outcome (slope) is the same for all groups

In R syntax: y ~ x + (1|group)

Example: Different schools might have different average test scores (random intercepts), but the effect of study hours on test scores is the same across all schools


Random Slope Model:

Allows the effect of a predictor (slope) to vary across groups. Can be used with or without random intercepts.

In R syntax: y ~ x + (0+x|group) for random slope only, or y ~ x + (1+x|group) for both random intercept and slope

Example: The effect of study hours on test scores might be stronger in some schools than others (random slopes)

Random intercept models account for different baselines between groups, while random slope models account for different relationships between predictors and outcomes across groups. When both random intercepts and slopes are included, you’re allowing both the baseline and the effect of predictors to vary by group.


Interactions between group-level (higher-level) variables and individual-level (lower-level) variables in mixed models are called cross-level interactions.

Cross-level interactions are particularly useful in multilevel research because they help you understand how the relationship between an individual-level predictor and the outcome varies as a function of a group-level characteristic.

For example, in educational research: 1) Individual level: student characteristics (study time, prior knowledge). 2) Group level: school or classroom characteristics (class size, teaching method). 3) Cross-level interaction: Does the effect of study time on performance depend on class size?

Running the glmer models

To model, we will follow: Approach to multilevel model building based on Hox (2010)

1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions

Each step, check whether your model is significantly improved compared to the previous one.

We could run these different models and select the best one: null_glmer -> only country random effects for a baseline glmer_stepwise -> using the best stepwise model best model for individual fixed effects + adding country random effects glmer_lasso -> using the lasso model fixed individual level effects + country glmer_level2 -> using the best model from above and adding in all country level fixed effects too glmer_cross_level -> the model using integrated

# Switching to df containing both individual and country level
complete_df <- complete_df |> 
  drop_na() # should be zero as we cleaned before but just in case 

# Scaling the variables speeds up the running time. However we loose interpretation? maybe the best thing to do is to center them rather than scaling?
scaled_df <- complete_df |>
  mutate(across(where(is.numeric), scale))

# include glmer null model for comparison for improvements - only has random intercept
null_glmer_model <- glmer(trans_docs ~ (1|country),
                          data = scaled_df, 
                          family=binomial(link="logit"))


## running the level 1 glmer model (indiviudal fixed effects + country random effects)
    # variable selection from the stepwise model output
# this took 7.6 minutes to run WITH the scaled data, saved output locally
      # start <- Sys.time()
      # glmer_model_level1 <- glmer(
      #   # target
      #   trans_docs ~
      #     #individual data - significant from stepwise testing
      #     age + gender + marital_status + occupation + 
      #     religion + phone_access + bill_issues + internet_use + life_sat + 
      #     left_right + ethnic_minority + roma_minority + suffered_discr + 
      #     gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri + 
      #     antilgbtq_rights + minority_discri + (1|country),
      #   data = scaled_df,
      #   family = binomial(link="logit")
      #     ) 
      # end <- Sys.time()
      # end-start

      # glmer_model_level1
      # output_glmer_1 <- broom.mixed::tidy(glmer_model_level1)

## running the level 2 glmer model (individual & country fixed effects + country random effects)

# took 10.8 minutes to run so commented out. Saved output locally 
      # start <- Sys.time()
      # glmer_model_level2 <- glmer(
      #   # target variable
      #   trans_docs ~
      #     #individual level fixed effects
      #     age + gender + marital_status + occupation +
      #     religion + phone_access + bill_issues + internet_use + life_sat +
      #     left_right + ethnic_minority + roma_minority + suffered_discr +
      #     gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri +
      #     antilgbtq_rights + minority_discri + 
      #     #country level fixed effects
      #     gdp_pc_ppp + gender_inequality_index + lgbt_policy_index + democracy_index +
      #     # random effects of country
      #     (1|country),
      #   data = scaled_df,
      #   family = binomial(link="logit")
      #           )
      # end <- Sys.time()
      # end-start
      # output_glmer_2 <- broom.mixed::tidy(glmer_model_level2)


# glmer model with cross-level interactions
glmer_model <- glmer(trans_docs ~ gender:lgbt_policy_index + gender*gender_inequality_index + religion*gdp_pc_ppp + (1 | country), data=scaled_df, family=binomial(link="logit"))



## saving the level1 and level2 outputs to file for review of full model effects
    #write_csv2(output_glmer_1, "glmer_level1_model_output.csv")
    #write_csv2(output_glmer_2, "glmer_level2_model_output.csv") 
## writing output for AIC/BIC and saving too    
    # glmer_compare <- anova(null_glmer_model, glmer_model_level1, glmer_model_level2, glmer_model)
    # write_csv2(glmer_compare, "glmer_compare_basicmodels.csv") 


#variable1*variable2 includes both the two variables separetely and their interaction
#variable1:variable2 includes only the interaction
#+ (1|country) country is the grouping variable, means it includes different intercepts for each country

summary(glmer_model) # print in better tables as Marga likes
## Generalized linear mixed model fit by maximum likelihood (Laplace
##   Approximation) [glmerMod]
##  Family: binomial  ( logit )
## Formula: 
## trans_docs ~ gender:lgbt_policy_index + gender * gender_inequality_index +  
##     religion * gdp_pc_ppp + (1 | country)
##    Data: scaled_df
## 
##      AIC      BIC   logLik deviance df.resid 
##  27760.0  27921.9 -13860.0  27720.0    24138 
## 
## Scaled residuals: 
##     Min      1Q  Median      3Q     Max 
## -2.7415 -0.6925 -0.4228  0.8840  4.3145 
## 
## Random effects:
##  Groups  Name        Variance Std.Dev.
##  country (Intercept) 0.2811   0.5302  
## Number of obs: 24158, groups:  country, 28
## 
## Fixed effects:
##                                       Estimate Std. Error z value Pr(>|z|)    
## (Intercept)                           -0.13257    0.10594  -1.251 0.210790    
## genderWoman                           -0.45316    0.03005 -15.078  < 2e-16 ***
## gender_inequality_index                0.24293    0.13636   1.782 0.074811 .  
## religionOrthodox Christian             0.14645    0.08192   1.788 0.073834 .  
## religionProtestant                    -0.13893    0.06647  -2.090 0.036598 *  
## religionOther Christian                0.12569    0.07722   1.628 0.103615    
## religionOther                         -0.21752    0.07083  -3.071 0.002132 ** 
## religionMuslim                         0.30066    0.12738   2.360 0.018262 *  
## religionNon-believers                 -0.56485    0.04552 -12.408  < 2e-16 ***
## gdp_pc_ppp                            -0.17013    0.10547  -1.613 0.106709    
## genderMan:lgbt_policy_index           -0.43634    0.12755  -3.421 0.000624 ***
## genderWoman:lgbt_policy_index         -0.56816    0.12745  -4.458 8.27e-06 ***
## genderWoman:gender_inequality_index    0.03763    0.04140   0.909 0.363389    
## religionOrthodox Christian:gdp_pc_ppp  0.16989    0.09191   1.848 0.064558 .  
## religionProtestant:gdp_pc_ppp          0.15569    0.08005   1.945 0.051789 .  
## religionOther Christian:gdp_pc_ppp     0.04970    0.08085   0.615 0.538751    
## religionOther:gdp_pc_ppp               0.10349    0.06960   1.487 0.137031    
## religionMuslim:gdp_pc_ppp              0.24136    0.12339   1.956 0.050455 .  
## religionNon-believers:gdp_pc_ppp       0.01368    0.04643   0.295 0.768327    
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Correlation matrix not shown by default, as p = 19 > 12.
## Use print(x, correlation=TRUE)  or
##     vcov(x)        if you need it
# To calculate the intraclass coefficient (ICC) for the model, we use the ICC function from performance. 

# Calculate ICC for the null model, we get around 22% explained 
performance::icc(null_glmer_model)
## # Intraclass Correlation Coefficient
## 
##     Adjusted ICC: 0.227
##   Unadjusted ICC: 0.227
# When we run for the model with scaled data, we get 7% ICC 
performance::icc(glmer_model)
## # Intraclass Correlation Coefficient
## 
##     Adjusted ICC: 0.079
##   Unadjusted ICC: 0.064
# this gives us the following significant variables: age, gender, occupation, religion, phone_access, bill_issues, internet_use, left_right, ethnic_minority_ 

# we exclude these non significant variable: martial_status,  

The idea is to run interactions between individual level variables and country level variables choosing pair which make sense (ex. does the effect of being female on support for trans docs depend on the gender equality index? –> did this by doing gender*gender_inequality_index)

Let’s use our brain and common sense to choose the best combinations

Predictive model

Summarize individual data to a country level (ex. percentage of population living in rural areas by country, percentage of people from minority x by country)

Run random forest/gradient boosting/logistic regression with leave-one-out cross validation

Leave-One-Out Cross-Validation (LOOCV): LOOCV is a special case of k-fold cross-validation, where k = the number of observations (n).

That means: For each observation (1 out of 28), the model is trained on the remaining 27 rows and tested on the left-out row. This process repeats 28 times (once per row). The final performance metric (e.g., accuracy, RMSE) is the average of all 28 test results.

Aggregating individual data to country level

We should be building a dataframe with 28 rows (1 per country), but many variables (ex, percentage of christian people by country, percentage of very satisfied with lives people by country, percentage of people that belong to the roma minority etc.; our target variable would become % of people that support trans_docs by country)

In the next steps we will synthesize the information from the individual respondents into country-level variables.

Using means for numeric variables:

names(select(final_data, where(is.numeric))) # using final_data because it still has "country", which we dropped for complete_df
## [1] "age"                      "years_edu"               
## [3] "social_alienation"        "n_friends_minorities"    
## [5] "n_actions_against_discri" "antilgbtq_rights"        
## [7] "minority_discri"
data_num <- final_data |> 
  group_by(country) |> 
  summarise(across(where(is.numeric), ~mean(.), .names = "mean_{.col}"))

As well as for dummies:

# searching for factor variables with two levels

dummy_names <- names(final_data)[sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2)]
dummy_names
##  [1] "gender"              "nonEU_national"      "ethnic_minority"    
##  [4] "skincolor_minority"  "religious_minority"  "roma_minority"      
##  [7] "sexual_minority"     "disability_minority" "suffered_discr"     
## [10] "gender_docs"         "trans_docs"
dummy_levels <- lapply(final_data[dummy_names], levels)
dummy_levels
## $gender
## [1] "Man"   "Woman"
## 
## $nonEU_national
## [1] "0" "1"
## 
## $ethnic_minority
## [1] "0" "1"
## 
## $skincolor_minority
## [1] "0" "1"
## 
## $religious_minority
## [1] "0" "1"
## 
## $roma_minority
## [1] "0" "1"
## 
## $sexual_minority
## [1] "0" "1"
## 
## $disability_minority
## [1] "0" "1"
## 
## $suffered_discr
## [1] "0" "1"
## 
## $gender_docs
## [1] "Yes" "No" 
## 
## $trans_docs
## [1] "Yes" "No"
colSums(is.na(final_data[dummy_names]))
##              gender      nonEU_national     ethnic_minority  skincolor_minority 
##                   0                   0                   0                   0 
##  religious_minority       roma_minority     sexual_minority disability_minority 
##                   0                   0                   0                   0 
##      suffered_discr         gender_docs          trans_docs 
##                   0                   0                3280

After imputations only the target variable should have NAs. They have already been dropped before so no variable has NAs

data_dummy <- final_data %>%
  select(country, all_of(dummy_names)) %>%
  mutate(across(all_of(dummy_names),
                ~ case_when(
                  . %in% c("0", "1") ~ as.numeric(as.character(.)),  # convert "0"/"1" to 0/1
                  . %in% c("Yes", "No") ~ recode(., "Yes" = 1, "No" = 0),  # convert "Yes"/"No" to 1/0
                  . %in% c("Man", "Woman") ~ recode(., "Man" = 1, "Woman" = 0),  # convert "Man"/"Woman" to 1/0
                  TRUE ~ NA  # assign NA to other unexpected values
                ),
                .names = "{.col}_num"))
## Warning: There were 3 warnings in `mutate()`.
## The first warning was:
## ℹ In argument: `across(...)`.
## Caused by warning:
## ! NAs introduced by coercion
## ℹ Run `dplyr::last_dplyr_warnings()` to see the 2 remaining warnings.
colSums(is.na(data_dummy)) # The warning is weird as there seem to be no NAs
##                 country                  gender          nonEU_national 
##                       0                       0                       0 
##         ethnic_minority      skincolor_minority      religious_minority 
##                       0                       0                       0 
##           roma_minority         sexual_minority     disability_minority 
##                       0                       0                       0 
##          suffered_discr             gender_docs              trans_docs 
##                       0                       0                    3280 
##              gender_num      nonEU_national_num     ethnic_minority_num 
##                       0                       0                       0 
##  skincolor_minority_num  religious_minority_num       roma_minority_num 
##                       0                       0                       0 
##     sexual_minority_num disability_minority_num      suffered_discr_num 
##                       0                       0                       0 
##         gender_docs_num          trans_docs_num 
##                       0                    3280

I converted factors with 2 levels to numerical 0-1 so we can compute their means.

Deleted the column calculating the % of NAs in trans_doc because although useful those NAs had already been dropped so it was returning all 0s

# country means
data_dummy <- data_dummy %>%
  group_by(country) %>%
  summarise(
    across(ends_with("_num"), ~ mean(.x, na.rm = TRUE)),
    .groups = "drop"
  )


# substitute the "_num" suffix with a "mean_" prefix so it has the same format as the variables in data_num
data_dummy <- data_dummy %>%
  rename_with(~ paste0("mean_", str_remove(., "_num$")), ends_with("_num"))

colSums(is.na(data_dummy))
##                  country              mean_gender      mean_nonEU_national 
##                        0                        0                        0 
##     mean_ethnic_minority  mean_skincolor_minority  mean_religious_minority 
##                        0                        0                        0 
##       mean_roma_minority     mean_sexual_minority mean_disability_minority 
##                        0                        0                        0 
##      mean_suffered_discr         mean_gender_docs          mean_trans_docs 
##                        0                        0                        0

Now we can join the two datasets.

data_aggr <- data_num %>%
  left_join(data_dummy, by = "country")

The next variables are factor with >2 levels:

factor_names <- names(final_data)[!sapply(final_data, is.numeric) &
              !(sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2))]
factor_names
##  [1] "country"        "community"      "marital_status" "occupation"    
##  [5] "social_class"   "religion"       "phone_access"   "bill_issues"   
##  [9] "internet_use"   "life_sat"       "polintr"        "left_right"    
## [13] "friends_trans"
# checking the levels
lapply(final_data[factor_names], levels)
## $country
## NULL
## 
## $community
## [1] "Rural area or village"      "Small or middle sized town"
## [3] "Large town"                
## 
## $marital_status
## [1] "(Re-)Married (1-4 in d7)"              
## [2] "Single living with partner (5-8 in d7)"
## [3] "Single (9-10 in d7)"                   
## [4] "Divorced or separated (11-12 in d7)"   
## [5] "Widow (13-14 in d7)"                   
## 
## $occupation
## [1] "Self-employed (5 to 9 in d15a)"        
## [2] "Managers (10 to 12 in d15a)"           
## [3] "Other white collars (13 or 14 in d15a)"
## [4] "Manual workers (15 to 18 in d15a)"     
## [5] "House persons (1 in d15a)"             
## [6] "Unemployed (3 in d15a)"                
## [7] "Retired (4 in d15a)"                   
## [8] "Students (2 in d15a)"                  
## 
## $social_class
## [1] "The working class of society"      "The lower middle class of society"
## [3] "The middle class of society"       "The upper middle class of society"
## [5] "The higher class of society"      
## 
## $religion
## [1] "Catholic"           "Orthodox Christian" "Protestant"        
## [4] "Other Christian"    "Other"              "Muslim"            
## [7] "Non-believers"     
## 
## $phone_access
## [1] "Mobile only"       "Landline only"     "Landline & mobile"
## [4] "No telephone"     
## 
## $bill_issues
## [1] "Most of the time"   "From time to time"  "Almost never/never"
## 
## $internet_use
## [1] "Everyday/Almost everyday"   "Two or three times a week" 
## [3] "About once a week"          "Two or three times a month"
## [5] "Less often"                 "Never/No access"           
## [7] "No Internet access at all" 
## 
## $life_sat
## [1] "Very satisfied"       "Fairly satisfied"     "Not very satisfied"  
## [4] "Not at all satisfied"
## 
## $polintr
## [1] "Strong"     "Medium"     "Low"        "Not at all"
## 
## $left_right
## [1] "(1 - 4) Left"   "(5 - 6) Centre" "(7 -10) Right" 
## 
## $friends_trans
## [1] "Yes"                   "No"                    "Refusal (SPONTANEOUS)"
# removing country from the list
factor_names <- setdiff(factor_names, "country")

# creating the aggregated dataset for factor variables

data_factors <- final_data %>%
  select(country, all_of(factor_names)) %>%
  pivot_longer(cols = -country, names_to = "variable", values_to = "level") %>%
  group_by(country, variable, level) %>%
  summarise(count = n(), .groups = "drop") %>%
  group_by(country, variable) %>%
  mutate(proportion = count / sum(count)) %>%
  select(-count) %>%
  pivot_wider(names_from = c(variable, level), values_from = proportion, names_glue = "{variable}_{level}")

colSums(is.na(data_factors))
##                                               country 
##                                                     0 
##                          bill_issues_Most of the time 
##                                                     0 
##                         bill_issues_From time to time 
##                                                     0 
##                        bill_issues_Almost never/never 
##                                                     0 
##                       community_Rural area or village 
##                                                     0 
##                  community_Small or middle sized town 
##                                                     0 
##                                  community_Large town 
##                                                     0 
##                                     friends_trans_Yes 
##                                                     0 
##                                      friends_trans_No 
##                                                     0 
##                   friends_trans_Refusal (SPONTANEOUS) 
##                                                     0 
##                 internet_use_Everyday/Almost everyday 
##                                                     0 
##                internet_use_Two or three times a week 
##                                                     0 
##                        internet_use_About once a week 
##                                                     1 
##               internet_use_Two or three times a month 
##                                                     0 
##                               internet_use_Less often 
##                                                     0 
##                          internet_use_Never/No access 
##                                                     0 
##                internet_use_No Internet access at all 
##                                                     0 
##                               left_right_(1 - 4) Left 
##                                                     0 
##                             left_right_(5 - 6) Centre 
##                                                     0 
##                              left_right_(7 -10) Right 
##                                                     0 
##                               life_sat_Very satisfied 
##                                                     0 
##                             life_sat_Fairly satisfied 
##                                                     0 
##                           life_sat_Not very satisfied 
##                                                     0 
##                         life_sat_Not at all satisfied 
##                                                     0 
##               marital_status_(Re-)Married (1-4 in d7) 
##                                                     0 
## marital_status_Single living with partner (5-8 in d7) 
##                                                     0 
##                    marital_status_Single (9-10 in d7) 
##                                                     0 
##    marital_status_Divorced or separated (11-12 in d7) 
##                                                     0 
##                    marital_status_Widow (13-14 in d7) 
##                                                     0 
##             occupation_Self-employed (5 to 9 in d15a) 
##                                                     0 
##                occupation_Managers (10 to 12 in d15a) 
##                                                     0 
##     occupation_Other white collars (13 or 14 in d15a) 
##                                                     0 
##          occupation_Manual workers (15 to 18 in d15a) 
##                                                     0 
##                  occupation_House persons (1 in d15a) 
##                                                     0 
##                     occupation_Unemployed (3 in d15a) 
##                                                     0 
##                        occupation_Retired (4 in d15a) 
##                                                     0 
##                       occupation_Students (2 in d15a) 
##                                                     0 
##                              phone_access_Mobile only 
##                                                     0 
##                            phone_access_Landline only 
##                                                     0 
##                        phone_access_Landline & mobile 
##                                                     0 
##                             phone_access_No telephone 
##                                                     1 
##                                        polintr_Strong 
##                                                     0 
##                                        polintr_Medium 
##                                                     0 
##                                           polintr_Low 
##                                                     0 
##                                    polintr_Not at all 
##                                                     0 
##                                     religion_Catholic 
##                                                     0 
##                           religion_Orthodox Christian 
##                                                     0 
##                                   religion_Protestant 
##                                                     1 
##                              religion_Other Christian 
##                                                     2 
##                                        religion_Other 
##                                                     0 
##                                       religion_Muslim 
##                                                     4 
##                                religion_Non-believers 
##                                                     0 
##             social_class_The working class of society 
##                                                     0 
##        social_class_The lower middle class of society 
##                                                     0 
##              social_class_The middle class of society 
##                                                     0 
##        social_class_The upper middle class of society 
##                                                     0 
##              social_class_The higher class of society 
##                                                     3

We are seeing NAs because in not all countries are all the factors’ levels represented. For example we see that social_class_The higher class of society has 3 missing values. Let’s confirm that there are 3 countries in our dataframe with no observation for that level

final_data |> filter(social_class=="The higher class of society") |>  pull(country) |> unique() |> length()
## [1] 25

Therefore those proportions should be 0s and not NAs

data_factors <- data_factors |>
  mutate(across(everything(), ~replace_na(., 0)))

Joining all together

data_aggr <- data_aggr |> 
  left_join(data_factors, by = "country")

Lastly, joining the country level variables obtained from external sources

data_aggr <- data_aggr |> 
  left_join(country_level_data, by = c("country" = "iso2c")) |> 
  select(-c(iso3c, country.y))
colSums(is.na(data_aggr))
##                                               country 
##                                                     0 
##                                              mean_age 
##                                                     0 
##                                        mean_years_edu 
##                                                     0 
##                                mean_social_alienation 
##                                                     0 
##                             mean_n_friends_minorities 
##                                                     0 
##                         mean_n_actions_against_discri 
##                                                     0 
##                                 mean_antilgbtq_rights 
##                                                     0 
##                                  mean_minority_discri 
##                                                     0 
##                                           mean_gender 
##                                                     0 
##                                   mean_nonEU_national 
##                                                     0 
##                                  mean_ethnic_minority 
##                                                     0 
##                               mean_skincolor_minority 
##                                                     0 
##                               mean_religious_minority 
##                                                     0 
##                                    mean_roma_minority 
##                                                     0 
##                                  mean_sexual_minority 
##                                                     0 
##                              mean_disability_minority 
##                                                     0 
##                                   mean_suffered_discr 
##                                                     0 
##                                      mean_gender_docs 
##                                                     0 
##                                       mean_trans_docs 
##                                                     0 
##                          bill_issues_Most of the time 
##                                                     0 
##                         bill_issues_From time to time 
##                                                     0 
##                        bill_issues_Almost never/never 
##                                                     0 
##                       community_Rural area or village 
##                                                     0 
##                  community_Small or middle sized town 
##                                                     0 
##                                  community_Large town 
##                                                     0 
##                                     friends_trans_Yes 
##                                                     0 
##                                      friends_trans_No 
##                                                     0 
##                   friends_trans_Refusal (SPONTANEOUS) 
##                                                     0 
##                 internet_use_Everyday/Almost everyday 
##                                                     0 
##                internet_use_Two or three times a week 
##                                                     0 
##                        internet_use_About once a week 
##                                                     0 
##               internet_use_Two or three times a month 
##                                                     0 
##                               internet_use_Less often 
##                                                     0 
##                          internet_use_Never/No access 
##                                                     0 
##                internet_use_No Internet access at all 
##                                                     0 
##                               left_right_(1 - 4) Left 
##                                                     0 
##                             left_right_(5 - 6) Centre 
##                                                     0 
##                              left_right_(7 -10) Right 
##                                                     0 
##                               life_sat_Very satisfied 
##                                                     0 
##                             life_sat_Fairly satisfied 
##                                                     0 
##                           life_sat_Not very satisfied 
##                                                     0 
##                         life_sat_Not at all satisfied 
##                                                     0 
##               marital_status_(Re-)Married (1-4 in d7) 
##                                                     0 
## marital_status_Single living with partner (5-8 in d7) 
##                                                     0 
##                    marital_status_Single (9-10 in d7) 
##                                                     0 
##    marital_status_Divorced or separated (11-12 in d7) 
##                                                     0 
##                    marital_status_Widow (13-14 in d7) 
##                                                     0 
##             occupation_Self-employed (5 to 9 in d15a) 
##                                                     0 
##                occupation_Managers (10 to 12 in d15a) 
##                                                     0 
##     occupation_Other white collars (13 or 14 in d15a) 
##                                                     0 
##          occupation_Manual workers (15 to 18 in d15a) 
##                                                     0 
##                  occupation_House persons (1 in d15a) 
##                                                     0 
##                     occupation_Unemployed (3 in d15a) 
##                                                     0 
##                        occupation_Retired (4 in d15a) 
##                                                     0 
##                       occupation_Students (2 in d15a) 
##                                                     0 
##                              phone_access_Mobile only 
##                                                     0 
##                            phone_access_Landline only 
##                                                     0 
##                        phone_access_Landline & mobile 
##                                                     0 
##                             phone_access_No telephone 
##                                                     0 
##                                        polintr_Strong 
##                                                     0 
##                                        polintr_Medium 
##                                                     0 
##                                           polintr_Low 
##                                                     0 
##                                    polintr_Not at all 
##                                                     0 
##                                     religion_Catholic 
##                                                     0 
##                           religion_Orthodox Christian 
##                                                     0 
##                                   religion_Protestant 
##                                                     0 
##                              religion_Other Christian 
##                                                     0 
##                                        religion_Other 
##                                                     0 
##                                       religion_Muslim 
##                                                     0 
##                                religion_Non-believers 
##                                                     0 
##             social_class_The working class of society 
##                                                     0 
##        social_class_The lower middle class of society 
##                                                     0 
##              social_class_The middle class of society 
##                                                     0 
##        social_class_The upper middle class of society 
##                                                     0 
##              social_class_The higher class of society 
##                                                     0 
##                                            gdp_pc_ppp 
##                                                     0 
##                               gender_inequality_index 
##                                                     0 
##                                     lgbt_policy_index 
##                                                     0 
##                                       democracy_index 
##                                                     0
dim(data_aggr)
## [1] 28 79

The resulting data frame has 28 observations and 79 variables. We might have to clean the names of the variables that were glued from variable_level.

Linear regression with LASSO

data_lasso <- data_aggr |> 
  select(-country)

# Define the leave-one-out cross-validation control
ctrl <- trainControl(
  method = "LOOCV",
  verboseIter = TRUE
)

# Set up the grid of lambda values for Lasso
lambda_grid <- 10^seq(-3, 3, length = 100)

# Train the Lasso model with LOOCV
lasso_model <- train(
  mean_trans_docs ~ ., 
  data = data_lasso, 
  method = "glmnet",
  preProc=c('scale','center'),
  trControl = ctrl,
  tuneGrid = expand.grid(
    alpha = 1,  # 1 for Lasso
    lambda = lambda_grid
  ),
  importance = TRUE,
  metric = "RMSE"
)
## + Fold01: alpha=1, lambda=1000 
## - Fold01: alpha=1, lambda=1000 
## + Fold02: alpha=1, lambda=1000 
## - Fold02: alpha=1, lambda=1000 
## + Fold03: alpha=1, lambda=1000 
## - Fold03: alpha=1, lambda=1000 
## + Fold04: alpha=1, lambda=1000 
## - Fold04: alpha=1, lambda=1000 
## + Fold05: alpha=1, lambda=1000 
## - Fold05: alpha=1, lambda=1000 
## + Fold06: alpha=1, lambda=1000 
## - Fold06: alpha=1, lambda=1000 
## + Fold07: alpha=1, lambda=1000 
## - Fold07: alpha=1, lambda=1000 
## + Fold08: alpha=1, lambda=1000 
## - Fold08: alpha=1, lambda=1000 
## + Fold09: alpha=1, lambda=1000 
## - Fold09: alpha=1, lambda=1000 
## + Fold10: alpha=1, lambda=1000 
## - Fold10: alpha=1, lambda=1000 
## + Fold11: alpha=1, lambda=1000 
## - Fold11: alpha=1, lambda=1000 
## + Fold12: alpha=1, lambda=1000 
## - Fold12: alpha=1, lambda=1000 
## + Fold13: alpha=1, lambda=1000 
## - Fold13: alpha=1, lambda=1000 
## + Fold14: alpha=1, lambda=1000 
## - Fold14: alpha=1, lambda=1000 
## + Fold15: alpha=1, lambda=1000 
## - Fold15: alpha=1, lambda=1000 
## + Fold16: alpha=1, lambda=1000 
## - Fold16: alpha=1, lambda=1000 
## + Fold17: alpha=1, lambda=1000 
## - Fold17: alpha=1, lambda=1000 
## + Fold18: alpha=1, lambda=1000 
## - Fold18: alpha=1, lambda=1000 
## + Fold19: alpha=1, lambda=1000 
## - Fold19: alpha=1, lambda=1000 
## + Fold20: alpha=1, lambda=1000 
## - Fold20: alpha=1, lambda=1000 
## + Fold21: alpha=1, lambda=1000 
## - Fold21: alpha=1, lambda=1000 
## + Fold22: alpha=1, lambda=1000 
## - Fold22: alpha=1, lambda=1000 
## + Fold23: alpha=1, lambda=1000 
## - Fold23: alpha=1, lambda=1000 
## + Fold24: alpha=1, lambda=1000 
## - Fold24: alpha=1, lambda=1000 
## + Fold25: alpha=1, lambda=1000 
## - Fold25: alpha=1, lambda=1000 
## + Fold26: alpha=1, lambda=1000 
## - Fold26: alpha=1, lambda=1000 
## + Fold27: alpha=1, lambda=1000 
## - Fold27: alpha=1, lambda=1000 
## + Fold28: alpha=1, lambda=1000 
## - Fold28: alpha=1, lambda=1000 
## Aggregating results
## Selecting tuning parameters
## Fitting alpha = 1, lambda = 0.0163 on full training set
# Print the best tuning parameter (lambda)
print(lasso_model$bestTune)
##    alpha     lambda
## 21     1 0.01629751
# Summarize the final model
print(lasso_model)
## glmnet 
## 
## 28 samples
## 77 predictors
## 
## Pre-processing: scaled (77), centered (77) 
## Resampling: Leave-One-Out Cross-Validation 
## Summary of sample sizes: 27, 27, 27, 27, 27, 27, ... 
## Resampling results across tuning parameters:
## 
##   lambda        RMSE        Rsquared   MAE       
##   1.000000e-03  0.10383281  0.7527260  0.08758219
##   1.149757e-03  0.10383281  0.7527260  0.08758219
##   1.321941e-03  0.10383281  0.7527260  0.08758219
##   1.519911e-03  0.10383281  0.7527260  0.08758219
##   1.747528e-03  0.10383281  0.7527260  0.08758219
##   2.009233e-03  0.10402767  0.7519423  0.08791975
##   2.310130e-03  0.10461221  0.7500256  0.08952507
##   2.656088e-03  0.10360276  0.7549616  0.08982328
##   3.053856e-03  0.10231113  0.7624769  0.08967178
##   3.511192e-03  0.10071627  0.7705257  0.08859326
##   4.037017e-03  0.09876515  0.7782737  0.08675034
##   4.641589e-03  0.09754309  0.7815376  0.08562794
##   5.336699e-03  0.09480301  0.7921722  0.08391056
##   6.135907e-03  0.08979748  0.8129860  0.07892787
##   7.054802e-03  0.08490749  0.8329937  0.07373353
##   8.111308e-03  0.08063554  0.8496713  0.06929678
##   9.326033e-03  0.07783049  0.8604324  0.06648746
##   1.072267e-02  0.07582093  0.8683450  0.06447392
##   1.232847e-02  0.07390484  0.8764899  0.06262299
##   1.417474e-02  0.07231164  0.8837525  0.06063496
##   1.629751e-02  0.07201306  0.8869303  0.05990110
##   1.873817e-02  0.07246559  0.8880918  0.06086861
##   2.154435e-02  0.07298646  0.8894410  0.06187848
##   2.477076e-02  0.07402423  0.8899153  0.06317244
##   2.848036e-02  0.07510115  0.8912782  0.06420057
##   3.274549e-02  0.07642657  0.8933710  0.06528348
##   3.764936e-02  0.07859592  0.8951661  0.06696827
##   4.328761e-02  0.08167235  0.8966355  0.06883089
##   4.977024e-02  0.08576341  0.8978095  0.07156834
##   5.722368e-02  0.09156221  0.8959180  0.07534686
##   6.579332e-02  0.09916970  0.8891343  0.08056696
##   7.564633e-02  0.10875071  0.8757446  0.08875632
##   8.697490e-02  0.11946558  0.8570995  0.09796251
##   1.000000e-01  0.13020231  0.8477038  0.10672825
##   1.149757e-01  0.14338089  0.8352499  0.11705874
##   1.321941e-01  0.15934474  0.8112914  0.13075534
##   1.519911e-01  0.17824636  0.7442530  0.14682227
##   1.747528e-01  0.20049562  0.2980089  0.16535467
##   2.009233e-01  0.21473400  1.0000000  0.18063976
##   2.310130e-01  0.21473400  1.0000000  0.18063976
##   2.656088e-01  0.21473400  1.0000000  0.18063976
##   3.053856e-01  0.21473400  1.0000000  0.18063976
##   3.511192e-01  0.21473400  1.0000000  0.18063976
##   4.037017e-01  0.21473400  1.0000000  0.18063976
##   4.641589e-01  0.21473400  1.0000000  0.18063976
##   5.336699e-01  0.21473400  1.0000000  0.18063976
##   6.135907e-01  0.21473400  1.0000000  0.18063976
##   7.054802e-01  0.21473400  1.0000000  0.18063976
##   8.111308e-01  0.21473400  1.0000000  0.18063976
##   9.326033e-01  0.21473400  1.0000000  0.18063976
##   1.072267e+00  0.21473400  1.0000000  0.18063976
##   1.232847e+00  0.21473400  1.0000000  0.18063976
##   1.417474e+00  0.21473400  1.0000000  0.18063976
##   1.629751e+00  0.21473400  1.0000000  0.18063976
##   1.873817e+00  0.21473400  1.0000000  0.18063976
##   2.154435e+00  0.21473400  1.0000000  0.18063976
##   2.477076e+00  0.21473400  1.0000000  0.18063976
##   2.848036e+00  0.21473400  1.0000000  0.18063976
##   3.274549e+00  0.21473400  1.0000000  0.18063976
##   3.764936e+00  0.21473400  1.0000000  0.18063976
##   4.328761e+00  0.21473400  1.0000000  0.18063976
##   4.977024e+00  0.21473400  1.0000000  0.18063976
##   5.722368e+00  0.21473400  1.0000000  0.18063976
##   6.579332e+00  0.21473400  1.0000000  0.18063976
##   7.564633e+00  0.21473400  1.0000000  0.18063976
##   8.697490e+00  0.21473400  1.0000000  0.18063976
##   1.000000e+01  0.21473400  1.0000000  0.18063976
##   1.149757e+01  0.21473400  1.0000000  0.18063976
##   1.321941e+01  0.21473400  1.0000000  0.18063976
##   1.519911e+01  0.21473400  1.0000000  0.18063976
##   1.747528e+01  0.21473400  1.0000000  0.18063976
##   2.009233e+01  0.21473400  1.0000000  0.18063976
##   2.310130e+01  0.21473400  1.0000000  0.18063976
##   2.656088e+01  0.21473400  1.0000000  0.18063976
##   3.053856e+01  0.21473400  1.0000000  0.18063976
##   3.511192e+01  0.21473400  1.0000000  0.18063976
##   4.037017e+01  0.21473400  1.0000000  0.18063976
##   4.641589e+01  0.21473400  1.0000000  0.18063976
##   5.336699e+01  0.21473400  1.0000000  0.18063976
##   6.135907e+01  0.21473400  1.0000000  0.18063976
##   7.054802e+01  0.21473400  1.0000000  0.18063976
##   8.111308e+01  0.21473400  1.0000000  0.18063976
##   9.326033e+01  0.21473400  1.0000000  0.18063976
##   1.072267e+02  0.21473400  1.0000000  0.18063976
##   1.232847e+02  0.21473400  1.0000000  0.18063976
##   1.417474e+02  0.21473400  1.0000000  0.18063976
##   1.629751e+02  0.21473400  1.0000000  0.18063976
##   1.873817e+02  0.21473400  1.0000000  0.18063976
##   2.154435e+02  0.21473400  1.0000000  0.18063976
##   2.477076e+02  0.21473400  1.0000000  0.18063976
##   2.848036e+02  0.21473400  1.0000000  0.18063976
##   3.274549e+02  0.21473400  1.0000000  0.18063976
##   3.764936e+02  0.21473400  1.0000000  0.18063976
##   4.328761e+02  0.21473400  1.0000000  0.18063976
##   4.977024e+02  0.21473400  1.0000000  0.18063976
##   5.722368e+02  0.21473400  1.0000000  0.18063976
##   6.579332e+02  0.21473400  1.0000000  0.18063976
##   7.564633e+02  0.21473400  1.0000000  0.18063976
##   8.697490e+02  0.21473400  1.0000000  0.18063976
##   1.000000e+03  0.21473400  1.0000000  0.18063976
## 
## Tuning parameter 'alpha' was held constant at a value of 1
## RMSE was used to select the optimal model using the smallest value.
## The final values used for the model were alpha = 1 and lambda = 0.01629751.
# Examine variable importance
importance <- varImp(lasso_model, scale = FALSE)
print(importance)
## glmnet variable importance
## 
##   only 20 most important variables shown (out of 77)
## 
##                                             Overall
## mean_gender_docs                           0.129202
## mean_roma_minority                         0.032442
## mean_antilgbtq_rights                      0.015207
## `friends_trans_Refusal (SPONTANEOUS)`      0.015012
## `life_sat_Not at all satisfied`            0.009104
## `phone_access_No telephone`                0.004799
## `internet_use_Two or three times a week`   0.004144
## mean_nonEU_national                        0.003555
## democracy_index                            0.001031
## `religion_Non-believers`                   0.000000
## mean_suffered_discr                        0.000000
## `internet_use_Never/No access`             0.000000
## `occupation_Unemployed (3 in d15a)`        0.000000
## `social_class_The higher class of society` 0.000000
## `religion_Other Christian`                 0.000000
## `internet_use_About once a week`           0.000000
## mean_religious_minority                    0.000000
## `life_sat_Very satisfied`                  0.000000
## `phone_access_Mobile only`                 0.000000
## `internet_use_Everyday/Almost everyday`    0.000000
plot(importance, top = 20)

# Get the coefficients of the best model
best_model <- lasso_model$finalModel
#coef_lasso <- coef(best_model) giving me errors
#print(coef_lasso)

# Calculate predictions and residuals
predictions <- predict(lasso_model, data_lasso)
# Extract the actual values
actual <- data_lasso$mean_trans_docs
# Calculate residuals
residuals <- actual - predictions


# Calculate R-squared and RMSE
r_squared <- 1 - sum(residuals^2) / sum((actual - mean(actual))^2)
rmse <- sqrt(mean(residuals^2))


cat("R-squared:", r_squared, "\n")
## R-squared: 0.9470027
cat("RMSE:", rmse, "\n")
## RMSE: 0.04766869
# Plot actual vs predicted values
plot(actual, predictions, 
     main = "Actual vs Predicted Values",
     xlab = "Actual", ylab = "Predicted",
     pch = 16, col = "blue")
abline(0, 1, col = "red")

# Plot residuals
plot(predictions, residuals,
     main = "Residuals vs Predicted Values",
     xlab = "Predicted Values", ylab = "Residuals",
     pch = 16, col = "blue")
abline(h = 0, col = "red")

# Combine country names with predictions
# Giving me errrors
# country_predictions <- data.frame(
#   country = data_aggr$country,
#   actual = target,
#   predicted = predictions
# )

# # Sort by prediction (descending)
# Giving me errors
# country_predictions <- country_predictions[order(country_predictions$predicted, decreasing = TRUE), ]
# print(country_predictions)

Random forest

data_aggr <- data_aggr |> 
  select(-country)

# Define LOOCV control
control <- trainControl(
  method = "LOOCV",
  verboseIter = TRUE,  # Print progress
  returnResamp = "all" # Save all resampling results
)

# Define hyperparameter grid for Random Forest
rf_grid <- expand.grid(
  mtry = seq(2, ncol(data_aggr) - 1, by = 2)
)
# mtry the number of variables randomly sampled at each split

# Train Random Forest model with hyperparameter tuning
rf_model <- train(
  mean_trans_docs ~ ., 
  data = data_aggr, 
  method = "rf",
  preProc=c('scale','center'),
  trControl = control,
  tuneGrid = rf_grid,
  importance = TRUE   # Calculate variable importance
)
## + Fold01: mtry= 2 
## - Fold01: mtry= 2 
## + Fold01: mtry= 4 
## - Fold01: mtry= 4 
## + Fold01: mtry= 6 
## - Fold01: mtry= 6 
## + Fold01: mtry= 8 
## - Fold01: mtry= 8 
## + Fold01: mtry=10 
## - Fold01: mtry=10 
## + Fold01: mtry=12 
## - Fold01: mtry=12 
## + Fold01: mtry=14 
## - Fold01: mtry=14 
## + Fold01: mtry=16 
## - Fold01: mtry=16 
## + Fold01: mtry=18 
## - Fold01: mtry=18 
## + Fold01: mtry=20 
## - Fold01: mtry=20 
## + Fold01: mtry=22 
## - Fold01: mtry=22 
## + Fold01: mtry=24 
## - Fold01: mtry=24 
## + Fold01: mtry=26 
## - Fold01: mtry=26 
## + Fold01: mtry=28 
## - Fold01: mtry=28 
## + Fold01: mtry=30 
## - Fold01: mtry=30 
## + Fold01: mtry=32 
## - Fold01: mtry=32 
## + Fold01: mtry=34 
## - Fold01: mtry=34 
## + Fold01: mtry=36 
## - Fold01: mtry=36 
## + Fold01: mtry=38 
## - Fold01: mtry=38 
## + Fold01: mtry=40 
## - Fold01: mtry=40 
## + Fold01: mtry=42 
## - Fold01: mtry=42 
## + Fold01: mtry=44 
## - Fold01: mtry=44 
## + Fold01: mtry=46 
## - Fold01: mtry=46 
## + Fold01: mtry=48 
## - Fold01: mtry=48 
## + Fold01: mtry=50 
## - Fold01: mtry=50 
## + Fold01: mtry=52 
## - Fold01: mtry=52 
## + Fold01: mtry=54 
## - Fold01: mtry=54 
## + Fold01: mtry=56 
## - Fold01: mtry=56 
## + Fold01: mtry=58 
## - Fold01: mtry=58 
## + Fold01: mtry=60 
## - Fold01: mtry=60 
## + Fold01: mtry=62 
## - Fold01: mtry=62 
## + Fold01: mtry=64 
## - Fold01: mtry=64 
## + Fold01: mtry=66 
## - Fold01: mtry=66 
## + Fold01: mtry=68 
## - Fold01: mtry=68 
## + Fold01: mtry=70 
## - Fold01: mtry=70 
## + Fold01: mtry=72 
## - Fold01: mtry=72 
## + Fold01: mtry=74 
## - Fold01: mtry=74 
## + Fold01: mtry=76 
## - Fold01: mtry=76 
## + Fold02: mtry= 2 
## - Fold02: mtry= 2 
## + Fold02: mtry= 4 
## - Fold02: mtry= 4 
## + Fold02: mtry= 6 
## - Fold02: mtry= 6 
## + Fold02: mtry= 8 
## - Fold02: mtry= 8 
## + Fold02: mtry=10 
## - Fold02: mtry=10 
## + Fold02: mtry=12 
## - Fold02: mtry=12 
## + Fold02: mtry=14 
## - Fold02: mtry=14 
## + Fold02: mtry=16 
## - Fold02: mtry=16 
## + Fold02: mtry=18 
## - Fold02: mtry=18 
## + Fold02: mtry=20 
## - Fold02: mtry=20 
## + Fold02: mtry=22 
## - Fold02: mtry=22 
## + Fold02: mtry=24 
## - Fold02: mtry=24 
## + Fold02: mtry=26 
## - Fold02: mtry=26 
## + Fold02: mtry=28 
## - Fold02: mtry=28 
## + Fold02: mtry=30 
## - Fold02: mtry=30 
## + Fold02: mtry=32 
## - Fold02: mtry=32 
## + Fold02: mtry=34 
## - Fold02: mtry=34 
## + Fold02: mtry=36 
## - Fold02: mtry=36 
## + Fold02: mtry=38 
## - Fold02: mtry=38 
## + Fold02: mtry=40 
## - Fold02: mtry=40 
## + Fold02: mtry=42 
## - Fold02: mtry=42 
## + Fold02: mtry=44 
## - Fold02: mtry=44 
## + Fold02: mtry=46 
## - Fold02: mtry=46 
## + Fold02: mtry=48 
## - Fold02: mtry=48 
## + Fold02: mtry=50 
## - Fold02: mtry=50 
## + Fold02: mtry=52 
## - Fold02: mtry=52 
## + Fold02: mtry=54 
## - Fold02: mtry=54 
## + Fold02: mtry=56 
## - Fold02: mtry=56 
## + Fold02: mtry=58 
## - Fold02: mtry=58 
## + Fold02: mtry=60 
## - Fold02: mtry=60 
## + Fold02: mtry=62 
## - Fold02: mtry=62 
## + Fold02: mtry=64 
## - Fold02: mtry=64 
## + Fold02: mtry=66 
## - Fold02: mtry=66 
## + Fold02: mtry=68 
## - Fold02: mtry=68 
## + Fold02: mtry=70 
## - Fold02: mtry=70 
## + Fold02: mtry=72 
## - Fold02: mtry=72 
## + Fold02: mtry=74 
## - Fold02: mtry=74 
## + Fold02: mtry=76 
## - Fold02: mtry=76 
## + Fold03: mtry= 2 
## - Fold03: mtry= 2 
## + Fold03: mtry= 4 
## - Fold03: mtry= 4 
## + Fold03: mtry= 6 
## - Fold03: mtry= 6 
## + Fold03: mtry= 8 
## - Fold03: mtry= 8 
## + Fold03: mtry=10 
## - Fold03: mtry=10 
## + Fold03: mtry=12 
## - Fold03: mtry=12 
## + Fold03: mtry=14 
## - Fold03: mtry=14 
## + Fold03: mtry=16 
## - Fold03: mtry=16 
## + Fold03: mtry=18 
## - Fold03: mtry=18 
## + Fold03: mtry=20 
## - Fold03: mtry=20 
## + Fold03: mtry=22 
## - Fold03: mtry=22 
## + Fold03: mtry=24 
## - Fold03: mtry=24 
## + Fold03: mtry=26 
## - Fold03: mtry=26 
## + Fold03: mtry=28 
## - Fold03: mtry=28 
## + Fold03: mtry=30 
## - Fold03: mtry=30 
## + Fold03: mtry=32 
## - Fold03: mtry=32 
## + Fold03: mtry=34 
## - Fold03: mtry=34 
## + Fold03: mtry=36 
## - Fold03: mtry=36 
## + Fold03: mtry=38 
## - Fold03: mtry=38 
## + Fold03: mtry=40 
## - Fold03: mtry=40 
## + Fold03: mtry=42 
## - Fold03: mtry=42 
## + Fold03: mtry=44 
## - Fold03: mtry=44 
## + Fold03: mtry=46 
## - Fold03: mtry=46 
## + Fold03: mtry=48 
## - Fold03: mtry=48 
## + Fold03: mtry=50 
## - Fold03: mtry=50 
## + Fold03: mtry=52 
## - Fold03: mtry=52 
## + Fold03: mtry=54 
## - Fold03: mtry=54 
## + Fold03: mtry=56 
## - Fold03: mtry=56 
## + Fold03: mtry=58 
## - Fold03: mtry=58 
## + Fold03: mtry=60 
## - Fold03: mtry=60 
## + Fold03: mtry=62 
## - Fold03: mtry=62 
## + Fold03: mtry=64 
## - Fold03: mtry=64 
## + Fold03: mtry=66 
## - Fold03: mtry=66 
## + Fold03: mtry=68 
## - Fold03: mtry=68 
## + Fold03: mtry=70 
## - Fold03: mtry=70 
## + Fold03: mtry=72 
## - Fold03: mtry=72 
## + Fold03: mtry=74 
## - Fold03: mtry=74 
## + Fold03: mtry=76 
## - Fold03: mtry=76 
## + Fold04: mtry= 2 
## - Fold04: mtry= 2 
## + Fold04: mtry= 4 
## - Fold04: mtry= 4 
## + Fold04: mtry= 6 
## - Fold04: mtry= 6 
## + Fold04: mtry= 8 
## - Fold04: mtry= 8 
## + Fold04: mtry=10 
## - Fold04: mtry=10 
## + Fold04: mtry=12 
## - Fold04: mtry=12 
## + Fold04: mtry=14 
## - Fold04: mtry=14 
## + Fold04: mtry=16 
## - Fold04: mtry=16 
## + Fold04: mtry=18 
## - Fold04: mtry=18 
## + Fold04: mtry=20 
## - Fold04: mtry=20 
## + Fold04: mtry=22 
## - Fold04: mtry=22 
## + Fold04: mtry=24 
## - Fold04: mtry=24 
## + Fold04: mtry=26 
## - Fold04: mtry=26 
## + Fold04: mtry=28 
## - Fold04: mtry=28 
## + Fold04: mtry=30 
## - Fold04: mtry=30 
## + Fold04: mtry=32 
## - Fold04: mtry=32 
## + Fold04: mtry=34 
## - Fold04: mtry=34 
## + Fold04: mtry=36 
## - Fold04: mtry=36 
## + Fold04: mtry=38 
## - Fold04: mtry=38 
## + Fold04: mtry=40 
## - Fold04: mtry=40 
## + Fold04: mtry=42 
## - Fold04: mtry=42 
## + Fold04: mtry=44 
## - Fold04: mtry=44 
## + Fold04: mtry=46 
## - Fold04: mtry=46 
## + Fold04: mtry=48 
## - Fold04: mtry=48 
## + Fold04: mtry=50 
## - Fold04: mtry=50 
## + Fold04: mtry=52 
## - Fold04: mtry=52 
## + Fold04: mtry=54 
## - Fold04: mtry=54 
## + Fold04: mtry=56 
## - Fold04: mtry=56 
## + Fold04: mtry=58 
## - Fold04: mtry=58 
## + Fold04: mtry=60 
## - Fold04: mtry=60 
## + Fold04: mtry=62 
## - Fold04: mtry=62 
## + Fold04: mtry=64 
## - Fold04: mtry=64 
## + Fold04: mtry=66 
## - Fold04: mtry=66 
## + Fold04: mtry=68 
## - Fold04: mtry=68 
## + Fold04: mtry=70 
## - Fold04: mtry=70 
## + Fold04: mtry=72 
## - Fold04: mtry=72 
## + Fold04: mtry=74 
## - Fold04: mtry=74 
## + Fold04: mtry=76 
## - Fold04: mtry=76 
## + Fold05: mtry= 2 
## - Fold05: mtry= 2 
## + Fold05: mtry= 4 
## - Fold05: mtry= 4 
## + Fold05: mtry= 6 
## - Fold05: mtry= 6 
## + Fold05: mtry= 8 
## - Fold05: mtry= 8 
## + Fold05: mtry=10 
## - Fold05: mtry=10 
## + Fold05: mtry=12 
## - Fold05: mtry=12 
## + Fold05: mtry=14 
## - Fold05: mtry=14 
## + Fold05: mtry=16 
## - Fold05: mtry=16 
## + Fold05: mtry=18 
## - Fold05: mtry=18 
## + Fold05: mtry=20 
## - Fold05: mtry=20 
## + Fold05: mtry=22 
## - Fold05: mtry=22 
## + Fold05: mtry=24 
## - Fold05: mtry=24 
## + Fold05: mtry=26 
## - Fold05: mtry=26 
## + Fold05: mtry=28 
## - Fold05: mtry=28 
## + Fold05: mtry=30 
## - Fold05: mtry=30 
## + Fold05: mtry=32 
## - Fold05: mtry=32 
## + Fold05: mtry=34 
## - Fold05: mtry=34 
## + Fold05: mtry=36 
## - Fold05: mtry=36 
## + Fold05: mtry=38 
## - Fold05: mtry=38 
## + Fold05: mtry=40 
## - Fold05: mtry=40 
## + Fold05: mtry=42 
## - Fold05: mtry=42 
## + Fold05: mtry=44 
## - Fold05: mtry=44 
## + Fold05: mtry=46 
## - Fold05: mtry=46 
## + Fold05: mtry=48 
## - Fold05: mtry=48 
## + Fold05: mtry=50 
## - Fold05: mtry=50 
## + Fold05: mtry=52 
## - Fold05: mtry=52 
## + Fold05: mtry=54 
## - Fold05: mtry=54 
## + Fold05: mtry=56 
## - Fold05: mtry=56 
## + Fold05: mtry=58 
## - Fold05: mtry=58 
## + Fold05: mtry=60 
## - Fold05: mtry=60 
## + Fold05: mtry=62 
## - Fold05: mtry=62 
## + Fold05: mtry=64 
## - Fold05: mtry=64 
## + Fold05: mtry=66 
## - Fold05: mtry=66 
## + Fold05: mtry=68 
## - Fold05: mtry=68 
## + Fold05: mtry=70 
## - Fold05: mtry=70 
## + Fold05: mtry=72 
## - Fold05: mtry=72 
## + Fold05: mtry=74 
## - Fold05: mtry=74 
## + Fold05: mtry=76 
## - Fold05: mtry=76 
## + Fold06: mtry= 2 
## - Fold06: mtry= 2 
## + Fold06: mtry= 4 
## - Fold06: mtry= 4 
## + Fold06: mtry= 6 
## - Fold06: mtry= 6 
## + Fold06: mtry= 8 
## - Fold06: mtry= 8 
## + Fold06: mtry=10 
## - Fold06: mtry=10 
## + Fold06: mtry=12 
## - Fold06: mtry=12 
## + Fold06: mtry=14 
## - Fold06: mtry=14 
## + Fold06: mtry=16 
## - Fold06: mtry=16 
## + Fold06: mtry=18 
## - Fold06: mtry=18 
## + Fold06: mtry=20 
## - Fold06: mtry=20 
## + Fold06: mtry=22 
## - Fold06: mtry=22 
## + Fold06: mtry=24 
## - Fold06: mtry=24 
## + Fold06: mtry=26 
## - Fold06: mtry=26 
## + Fold06: mtry=28 
## - Fold06: mtry=28 
## + Fold06: mtry=30 
## - Fold06: mtry=30 
## + Fold06: mtry=32 
## - Fold06: mtry=32 
## + Fold06: mtry=34 
## - Fold06: mtry=34 
## + Fold06: mtry=36 
## - Fold06: mtry=36 
## + Fold06: mtry=38 
## - Fold06: mtry=38 
## + Fold06: mtry=40 
## - Fold06: mtry=40 
## + Fold06: mtry=42 
## - Fold06: mtry=42 
## + Fold06: mtry=44 
## - Fold06: mtry=44 
## + Fold06: mtry=46 
## - Fold06: mtry=46 
## + Fold06: mtry=48 
## - Fold06: mtry=48 
## + Fold06: mtry=50 
## - Fold06: mtry=50 
## + Fold06: mtry=52 
## - Fold06: mtry=52 
## + Fold06: mtry=54 
## - Fold06: mtry=54 
## + Fold06: mtry=56 
## - Fold06: mtry=56 
## + Fold06: mtry=58 
## - Fold06: mtry=58 
## + Fold06: mtry=60 
## - Fold06: mtry=60 
## + Fold06: mtry=62 
## - Fold06: mtry=62 
## + Fold06: mtry=64 
## - Fold06: mtry=64 
## + Fold06: mtry=66 
## - Fold06: mtry=66 
## + Fold06: mtry=68 
## - Fold06: mtry=68 
## + Fold06: mtry=70 
## - Fold06: mtry=70 
## + Fold06: mtry=72 
## - Fold06: mtry=72 
## + Fold06: mtry=74 
## - Fold06: mtry=74 
## + Fold06: mtry=76 
## - Fold06: mtry=76 
## + Fold07: mtry= 2 
## - Fold07: mtry= 2 
## + Fold07: mtry= 4 
## - Fold07: mtry= 4 
## + Fold07: mtry= 6 
## - Fold07: mtry= 6 
## + Fold07: mtry= 8 
## - Fold07: mtry= 8 
## + Fold07: mtry=10 
## - Fold07: mtry=10 
## + Fold07: mtry=12 
## - Fold07: mtry=12 
## + Fold07: mtry=14 
## - Fold07: mtry=14 
## + Fold07: mtry=16 
## - Fold07: mtry=16 
## + Fold07: mtry=18 
## - Fold07: mtry=18 
## + Fold07: mtry=20 
## - Fold07: mtry=20 
## + Fold07: mtry=22 
## - Fold07: mtry=22 
## + Fold07: mtry=24 
## - Fold07: mtry=24 
## + Fold07: mtry=26 
## - Fold07: mtry=26 
## + Fold07: mtry=28 
## - Fold07: mtry=28 
## + Fold07: mtry=30 
## - Fold07: mtry=30 
## + Fold07: mtry=32 
## - Fold07: mtry=32 
## + Fold07: mtry=34 
## - Fold07: mtry=34 
## + Fold07: mtry=36 
## - Fold07: mtry=36 
## + Fold07: mtry=38 
## - Fold07: mtry=38 
## + Fold07: mtry=40 
## - Fold07: mtry=40 
## + Fold07: mtry=42 
## - Fold07: mtry=42 
## + Fold07: mtry=44 
## - Fold07: mtry=44 
## + Fold07: mtry=46 
## - Fold07: mtry=46 
## + Fold07: mtry=48 
## - Fold07: mtry=48 
## + Fold07: mtry=50 
## - Fold07: mtry=50 
## + Fold07: mtry=52 
## - Fold07: mtry=52 
## + Fold07: mtry=54 
## - Fold07: mtry=54 
## + Fold07: mtry=56 
## - Fold07: mtry=56 
## + Fold07: mtry=58 
## - Fold07: mtry=58 
## + Fold07: mtry=60 
## - Fold07: mtry=60 
## + Fold07: mtry=62 
## - Fold07: mtry=62 
## + Fold07: mtry=64 
## - Fold07: mtry=64 
## + Fold07: mtry=66 
## - Fold07: mtry=66 
## + Fold07: mtry=68 
## - Fold07: mtry=68 
## + Fold07: mtry=70 
## - Fold07: mtry=70 
## + Fold07: mtry=72 
## - Fold07: mtry=72 
## + Fold07: mtry=74 
## - Fold07: mtry=74 
## + Fold07: mtry=76 
## - Fold07: mtry=76 
## + Fold08: mtry= 2 
## - Fold08: mtry= 2 
## + Fold08: mtry= 4 
## - Fold08: mtry= 4 
## + Fold08: mtry= 6 
## - Fold08: mtry= 6 
## + Fold08: mtry= 8 
## - Fold08: mtry= 8 
## + Fold08: mtry=10 
## - Fold08: mtry=10 
## + Fold08: mtry=12 
## - Fold08: mtry=12 
## + Fold08: mtry=14 
## - Fold08: mtry=14 
## + Fold08: mtry=16 
## - Fold08: mtry=16 
## + Fold08: mtry=18 
## - Fold08: mtry=18 
## + Fold08: mtry=20 
## - Fold08: mtry=20 
## + Fold08: mtry=22 
## - Fold08: mtry=22 
## + Fold08: mtry=24 
## - Fold08: mtry=24 
## + Fold08: mtry=26 
## - Fold08: mtry=26 
## + Fold08: mtry=28 
## - Fold08: mtry=28 
## + Fold08: mtry=30 
## - Fold08: mtry=30 
## + Fold08: mtry=32 
## - Fold08: mtry=32 
## + Fold08: mtry=34 
## - Fold08: mtry=34 
## + Fold08: mtry=36 
## - Fold08: mtry=36 
## + Fold08: mtry=38 
## - Fold08: mtry=38 
## + Fold08: mtry=40 
## - Fold08: mtry=40 
## + Fold08: mtry=42 
## - Fold08: mtry=42 
## + Fold08: mtry=44 
## - Fold08: mtry=44 
## + Fold08: mtry=46 
## - Fold08: mtry=46 
## + Fold08: mtry=48 
## - Fold08: mtry=48 
## + Fold08: mtry=50 
## - Fold08: mtry=50 
## + Fold08: mtry=52 
## - Fold08: mtry=52 
## + Fold08: mtry=54 
## - Fold08: mtry=54 
## + Fold08: mtry=56 
## - Fold08: mtry=56 
## + Fold08: mtry=58 
## - Fold08: mtry=58 
## + Fold08: mtry=60 
## - Fold08: mtry=60 
## + Fold08: mtry=62 
## - Fold08: mtry=62 
## + Fold08: mtry=64 
## - Fold08: mtry=64 
## + Fold08: mtry=66 
## - Fold08: mtry=66 
## + Fold08: mtry=68 
## - Fold08: mtry=68 
## + Fold08: mtry=70 
## - Fold08: mtry=70 
## + Fold08: mtry=72 
## - Fold08: mtry=72 
## + Fold08: mtry=74 
## - Fold08: mtry=74 
## + Fold08: mtry=76 
## - Fold08: mtry=76 
## + Fold09: mtry= 2 
## - Fold09: mtry= 2 
## + Fold09: mtry= 4 
## - Fold09: mtry= 4 
## + Fold09: mtry= 6 
## - Fold09: mtry= 6 
## + Fold09: mtry= 8 
## - Fold09: mtry= 8 
## + Fold09: mtry=10 
## - Fold09: mtry=10 
## + Fold09: mtry=12 
## - Fold09: mtry=12 
## + Fold09: mtry=14 
## - Fold09: mtry=14 
## + Fold09: mtry=16 
## - Fold09: mtry=16 
## + Fold09: mtry=18 
## - Fold09: mtry=18 
## + Fold09: mtry=20 
## - Fold09: mtry=20 
## + Fold09: mtry=22 
## - Fold09: mtry=22 
## + Fold09: mtry=24 
## - Fold09: mtry=24 
## + Fold09: mtry=26 
## - Fold09: mtry=26 
## + Fold09: mtry=28 
## - Fold09: mtry=28 
## + Fold09: mtry=30 
## - Fold09: mtry=30 
## + Fold09: mtry=32 
## - Fold09: mtry=32 
## + Fold09: mtry=34 
## - Fold09: mtry=34 
## + Fold09: mtry=36 
## - Fold09: mtry=36 
## + Fold09: mtry=38 
## - Fold09: mtry=38 
## + Fold09: mtry=40 
## - Fold09: mtry=40 
## + Fold09: mtry=42 
## - Fold09: mtry=42 
## + Fold09: mtry=44 
## - Fold09: mtry=44 
## + Fold09: mtry=46 
## - Fold09: mtry=46 
## + Fold09: mtry=48 
## - Fold09: mtry=48 
## + Fold09: mtry=50 
## - Fold09: mtry=50 
## + Fold09: mtry=52 
## - Fold09: mtry=52 
## + Fold09: mtry=54 
## - Fold09: mtry=54 
## + Fold09: mtry=56 
## - Fold09: mtry=56 
## + Fold09: mtry=58 
## - Fold09: mtry=58 
## + Fold09: mtry=60 
## - Fold09: mtry=60 
## + Fold09: mtry=62 
## - Fold09: mtry=62 
## + Fold09: mtry=64 
## - Fold09: mtry=64 
## + Fold09: mtry=66 
## - Fold09: mtry=66 
## + Fold09: mtry=68 
## - Fold09: mtry=68 
## + Fold09: mtry=70 
## - Fold09: mtry=70 
## + Fold09: mtry=72 
## - Fold09: mtry=72 
## + Fold09: mtry=74 
## - Fold09: mtry=74 
## + Fold09: mtry=76 
## - Fold09: mtry=76 
## + Fold10: mtry= 2 
## - Fold10: mtry= 2 
## + Fold10: mtry= 4 
## - Fold10: mtry= 4 
## + Fold10: mtry= 6 
## - Fold10: mtry= 6 
## + Fold10: mtry= 8 
## - Fold10: mtry= 8 
## + Fold10: mtry=10 
## - Fold10: mtry=10 
## + Fold10: mtry=12 
## - Fold10: mtry=12 
## + Fold10: mtry=14 
## - Fold10: mtry=14 
## + Fold10: mtry=16 
## - Fold10: mtry=16 
## + Fold10: mtry=18 
## - Fold10: mtry=18 
## + Fold10: mtry=20 
## - Fold10: mtry=20 
## + Fold10: mtry=22 
## - Fold10: mtry=22 
## + Fold10: mtry=24 
## - Fold10: mtry=24 
## + Fold10: mtry=26 
## - Fold10: mtry=26 
## + Fold10: mtry=28 
## - Fold10: mtry=28 
## + Fold10: mtry=30 
## - Fold10: mtry=30 
## + Fold10: mtry=32 
## - Fold10: mtry=32 
## + Fold10: mtry=34 
## - Fold10: mtry=34 
## + Fold10: mtry=36 
## - Fold10: mtry=36 
## + Fold10: mtry=38 
## - Fold10: mtry=38 
## + Fold10: mtry=40 
## - Fold10: mtry=40 
## + Fold10: mtry=42 
## - Fold10: mtry=42 
## + Fold10: mtry=44 
## - Fold10: mtry=44 
## + Fold10: mtry=46 
## - Fold10: mtry=46 
## + Fold10: mtry=48 
## - Fold10: mtry=48 
## + Fold10: mtry=50 
## - Fold10: mtry=50 
## + Fold10: mtry=52 
## - Fold10: mtry=52 
## + Fold10: mtry=54 
## - Fold10: mtry=54 
## + Fold10: mtry=56 
## - Fold10: mtry=56 
## + Fold10: mtry=58 
## - Fold10: mtry=58 
## + Fold10: mtry=60 
## - Fold10: mtry=60 
## + Fold10: mtry=62 
## - Fold10: mtry=62 
## + Fold10: mtry=64 
## - Fold10: mtry=64 
## + Fold10: mtry=66 
## - Fold10: mtry=66 
## + Fold10: mtry=68 
## - Fold10: mtry=68 
## + Fold10: mtry=70 
## - Fold10: mtry=70 
## + Fold10: mtry=72 
## - Fold10: mtry=72 
## + Fold10: mtry=74 
## - Fold10: mtry=74 
## + Fold10: mtry=76 
## - Fold10: mtry=76 
## + Fold11: mtry= 2 
## - Fold11: mtry= 2 
## + Fold11: mtry= 4 
## - Fold11: mtry= 4 
## + Fold11: mtry= 6 
## - Fold11: mtry= 6 
## + Fold11: mtry= 8 
## - Fold11: mtry= 8 
## + Fold11: mtry=10 
## - Fold11: mtry=10 
## + Fold11: mtry=12 
## - Fold11: mtry=12 
## + Fold11: mtry=14 
## - Fold11: mtry=14 
## + Fold11: mtry=16 
## - Fold11: mtry=16 
## + Fold11: mtry=18 
## - Fold11: mtry=18 
## + Fold11: mtry=20 
## - Fold11: mtry=20 
## + Fold11: mtry=22 
## - Fold11: mtry=22 
## + Fold11: mtry=24 
## - Fold11: mtry=24 
## + Fold11: mtry=26 
## - Fold11: mtry=26 
## + Fold11: mtry=28 
## - Fold11: mtry=28 
## + Fold11: mtry=30 
## - Fold11: mtry=30 
## + Fold11: mtry=32 
## - Fold11: mtry=32 
## + Fold11: mtry=34 
## - Fold11: mtry=34 
## + Fold11: mtry=36 
## - Fold11: mtry=36 
## + Fold11: mtry=38 
## - Fold11: mtry=38 
## + Fold11: mtry=40 
## - Fold11: mtry=40 
## + Fold11: mtry=42 
## - Fold11: mtry=42 
## + Fold11: mtry=44 
## - Fold11: mtry=44 
## + Fold11: mtry=46 
## - Fold11: mtry=46 
## + Fold11: mtry=48 
## - Fold11: mtry=48 
## + Fold11: mtry=50 
## - Fold11: mtry=50 
## + Fold11: mtry=52 
## - Fold11: mtry=52 
## + Fold11: mtry=54 
## - Fold11: mtry=54 
## + Fold11: mtry=56 
## - Fold11: mtry=56 
## + Fold11: mtry=58 
## - Fold11: mtry=58 
## + Fold11: mtry=60 
## - Fold11: mtry=60 
## + Fold11: mtry=62 
## - Fold11: mtry=62 
## + Fold11: mtry=64 
## - Fold11: mtry=64 
## + Fold11: mtry=66 
## - Fold11: mtry=66 
## + Fold11: mtry=68 
## - Fold11: mtry=68 
## + Fold11: mtry=70 
## - Fold11: mtry=70 
## + Fold11: mtry=72 
## - Fold11: mtry=72 
## + Fold11: mtry=74 
## - Fold11: mtry=74 
## + Fold11: mtry=76 
## - Fold11: mtry=76 
## + Fold12: mtry= 2 
## - Fold12: mtry= 2 
## + Fold12: mtry= 4 
## - Fold12: mtry= 4 
## + Fold12: mtry= 6 
## - Fold12: mtry= 6 
## + Fold12: mtry= 8 
## - Fold12: mtry= 8 
## + Fold12: mtry=10 
## - Fold12: mtry=10 
## + Fold12: mtry=12 
## - Fold12: mtry=12 
## + Fold12: mtry=14 
## - Fold12: mtry=14 
## + Fold12: mtry=16 
## - Fold12: mtry=16 
## + Fold12: mtry=18 
## - Fold12: mtry=18 
## + Fold12: mtry=20 
## - Fold12: mtry=20 
## + Fold12: mtry=22 
## - Fold12: mtry=22 
## + Fold12: mtry=24 
## - Fold12: mtry=24 
## + Fold12: mtry=26 
## - Fold12: mtry=26 
## + Fold12: mtry=28 
## - Fold12: mtry=28 
## + Fold12: mtry=30 
## - Fold12: mtry=30 
## + Fold12: mtry=32 
## - Fold12: mtry=32 
## + Fold12: mtry=34 
## - Fold12: mtry=34 
## + Fold12: mtry=36 
## - Fold12: mtry=36 
## + Fold12: mtry=38 
## - Fold12: mtry=38 
## + Fold12: mtry=40 
## - Fold12: mtry=40 
## + Fold12: mtry=42 
## - Fold12: mtry=42 
## + Fold12: mtry=44 
## - Fold12: mtry=44 
## + Fold12: mtry=46 
## - Fold12: mtry=46 
## + Fold12: mtry=48 
## - Fold12: mtry=48 
## + Fold12: mtry=50 
## - Fold12: mtry=50 
## + Fold12: mtry=52 
## - Fold12: mtry=52 
## + Fold12: mtry=54 
## - Fold12: mtry=54 
## + Fold12: mtry=56 
## - Fold12: mtry=56 
## + Fold12: mtry=58 
## - Fold12: mtry=58 
## + Fold12: mtry=60 
## - Fold12: mtry=60 
## + Fold12: mtry=62 
## - Fold12: mtry=62 
## + Fold12: mtry=64 
## - Fold12: mtry=64 
## + Fold12: mtry=66 
## - Fold12: mtry=66 
## + Fold12: mtry=68 
## - Fold12: mtry=68 
## + Fold12: mtry=70 
## - Fold12: mtry=70 
## + Fold12: mtry=72 
## - Fold12: mtry=72 
## + Fold12: mtry=74 
## - Fold12: mtry=74 
## + Fold12: mtry=76 
## - Fold12: mtry=76 
## + Fold13: mtry= 2 
## - Fold13: mtry= 2 
## + Fold13: mtry= 4 
## - Fold13: mtry= 4 
## + Fold13: mtry= 6 
## - Fold13: mtry= 6 
## + Fold13: mtry= 8 
## - Fold13: mtry= 8 
## + Fold13: mtry=10 
## - Fold13: mtry=10 
## + Fold13: mtry=12 
## - Fold13: mtry=12 
## + Fold13: mtry=14 
## - Fold13: mtry=14 
## + Fold13: mtry=16 
## - Fold13: mtry=16 
## + Fold13: mtry=18 
## - Fold13: mtry=18 
## + Fold13: mtry=20 
## - Fold13: mtry=20 
## + Fold13: mtry=22 
## - Fold13: mtry=22 
## + Fold13: mtry=24 
## - Fold13: mtry=24 
## + Fold13: mtry=26 
## - Fold13: mtry=26 
## + Fold13: mtry=28 
## - Fold13: mtry=28 
## + Fold13: mtry=30 
## - Fold13: mtry=30 
## + Fold13: mtry=32 
## - Fold13: mtry=32 
## + Fold13: mtry=34 
## - Fold13: mtry=34 
## + Fold13: mtry=36 
## - Fold13: mtry=36 
## + Fold13: mtry=38 
## - Fold13: mtry=38 
## + Fold13: mtry=40 
## - Fold13: mtry=40 
## + Fold13: mtry=42 
## - Fold13: mtry=42 
## + Fold13: mtry=44 
## - Fold13: mtry=44 
## + Fold13: mtry=46 
## - Fold13: mtry=46 
## + Fold13: mtry=48 
## - Fold13: mtry=48 
## + Fold13: mtry=50 
## - Fold13: mtry=50 
## + Fold13: mtry=52 
## - Fold13: mtry=52 
## + Fold13: mtry=54 
## - Fold13: mtry=54 
## + Fold13: mtry=56 
## - Fold13: mtry=56 
## + Fold13: mtry=58 
## - Fold13: mtry=58 
## + Fold13: mtry=60 
## - Fold13: mtry=60 
## + Fold13: mtry=62 
## - Fold13: mtry=62 
## + Fold13: mtry=64 
## - Fold13: mtry=64 
## + Fold13: mtry=66 
## - Fold13: mtry=66 
## + Fold13: mtry=68 
## - Fold13: mtry=68 
## + Fold13: mtry=70 
## - Fold13: mtry=70 
## + Fold13: mtry=72 
## - Fold13: mtry=72 
## + Fold13: mtry=74 
## - Fold13: mtry=74 
## + Fold13: mtry=76 
## - Fold13: mtry=76 
## + Fold14: mtry= 2 
## - Fold14: mtry= 2 
## + Fold14: mtry= 4 
## - Fold14: mtry= 4 
## + Fold14: mtry= 6 
## - Fold14: mtry= 6 
## + Fold14: mtry= 8 
## - Fold14: mtry= 8 
## + Fold14: mtry=10 
## - Fold14: mtry=10 
## + Fold14: mtry=12 
## - Fold14: mtry=12 
## + Fold14: mtry=14 
## - Fold14: mtry=14 
## + Fold14: mtry=16 
## - Fold14: mtry=16 
## + Fold14: mtry=18 
## - Fold14: mtry=18 
## + Fold14: mtry=20 
## - Fold14: mtry=20 
## + Fold14: mtry=22 
## - Fold14: mtry=22 
## + Fold14: mtry=24 
## - Fold14: mtry=24 
## + Fold14: mtry=26 
## - Fold14: mtry=26 
## + Fold14: mtry=28 
## - Fold14: mtry=28 
## + Fold14: mtry=30 
## - Fold14: mtry=30 
## + Fold14: mtry=32 
## - Fold14: mtry=32 
## + Fold14: mtry=34 
## - Fold14: mtry=34 
## + Fold14: mtry=36 
## - Fold14: mtry=36 
## + Fold14: mtry=38 
## - Fold14: mtry=38 
## + Fold14: mtry=40 
## - Fold14: mtry=40 
## + Fold14: mtry=42 
## - Fold14: mtry=42 
## + Fold14: mtry=44 
## - Fold14: mtry=44 
## + Fold14: mtry=46 
## - Fold14: mtry=46 
## + Fold14: mtry=48 
## - Fold14: mtry=48 
## + Fold14: mtry=50 
## - Fold14: mtry=50 
## + Fold14: mtry=52 
## - Fold14: mtry=52 
## + Fold14: mtry=54 
## - Fold14: mtry=54 
## + Fold14: mtry=56 
## - Fold14: mtry=56 
## + Fold14: mtry=58 
## - Fold14: mtry=58 
## + Fold14: mtry=60 
## - Fold14: mtry=60 
## + Fold14: mtry=62 
## - Fold14: mtry=62 
## + Fold14: mtry=64 
## - Fold14: mtry=64 
## + Fold14: mtry=66 
## - Fold14: mtry=66 
## + Fold14: mtry=68 
## - Fold14: mtry=68 
## + Fold14: mtry=70 
## - Fold14: mtry=70 
## + Fold14: mtry=72 
## - Fold14: mtry=72 
## + Fold14: mtry=74 
## - Fold14: mtry=74 
## + Fold14: mtry=76 
## - Fold14: mtry=76 
## + Fold15: mtry= 2 
## - Fold15: mtry= 2 
## + Fold15: mtry= 4 
## - Fold15: mtry= 4 
## + Fold15: mtry= 6 
## - Fold15: mtry= 6 
## + Fold15: mtry= 8 
## - Fold15: mtry= 8 
## + Fold15: mtry=10 
## - Fold15: mtry=10 
## + Fold15: mtry=12 
## - Fold15: mtry=12 
## + Fold15: mtry=14 
## - Fold15: mtry=14 
## + Fold15: mtry=16 
## - Fold15: mtry=16 
## + Fold15: mtry=18 
## - Fold15: mtry=18 
## + Fold15: mtry=20 
## - Fold15: mtry=20 
## + Fold15: mtry=22 
## - Fold15: mtry=22 
## + Fold15: mtry=24 
## - Fold15: mtry=24 
## + Fold15: mtry=26 
## - Fold15: mtry=26 
## + Fold15: mtry=28 
## - Fold15: mtry=28 
## + Fold15: mtry=30 
## - Fold15: mtry=30 
## + Fold15: mtry=32 
## - Fold15: mtry=32 
## + Fold15: mtry=34 
## - Fold15: mtry=34 
## + Fold15: mtry=36 
## - Fold15: mtry=36 
## + Fold15: mtry=38 
## - Fold15: mtry=38 
## + Fold15: mtry=40 
## - Fold15: mtry=40 
## + Fold15: mtry=42 
## - Fold15: mtry=42 
## + Fold15: mtry=44 
## - Fold15: mtry=44 
## + Fold15: mtry=46 
## - Fold15: mtry=46 
## + Fold15: mtry=48 
## - Fold15: mtry=48 
## + Fold15: mtry=50 
## - Fold15: mtry=50 
## + Fold15: mtry=52 
## - Fold15: mtry=52 
## + Fold15: mtry=54 
## - Fold15: mtry=54 
## + Fold15: mtry=56 
## - Fold15: mtry=56 
## + Fold15: mtry=58 
## - Fold15: mtry=58 
## + Fold15: mtry=60 
## - Fold15: mtry=60 
## + Fold15: mtry=62 
## - Fold15: mtry=62 
## + Fold15: mtry=64 
## - Fold15: mtry=64 
## + Fold15: mtry=66 
## - Fold15: mtry=66 
## + Fold15: mtry=68 
## - Fold15: mtry=68 
## + Fold15: mtry=70 
## - Fold15: mtry=70 
## + Fold15: mtry=72 
## - Fold15: mtry=72 
## + Fold15: mtry=74 
## - Fold15: mtry=74 
## + Fold15: mtry=76 
## - Fold15: mtry=76 
## + Fold16: mtry= 2 
## - Fold16: mtry= 2 
## + Fold16: mtry= 4 
## - Fold16: mtry= 4 
## + Fold16: mtry= 6 
## - Fold16: mtry= 6 
## + Fold16: mtry= 8 
## - Fold16: mtry= 8 
## + Fold16: mtry=10 
## - Fold16: mtry=10 
## + Fold16: mtry=12 
## - Fold16: mtry=12 
## + Fold16: mtry=14 
## - Fold16: mtry=14 
## + Fold16: mtry=16 
## - Fold16: mtry=16 
## + Fold16: mtry=18 
## - Fold16: mtry=18 
## + Fold16: mtry=20 
## - Fold16: mtry=20 
## + Fold16: mtry=22 
## - Fold16: mtry=22 
## + Fold16: mtry=24 
## - Fold16: mtry=24 
## + Fold16: mtry=26 
## - Fold16: mtry=26 
## + Fold16: mtry=28 
## - Fold16: mtry=28 
## + Fold16: mtry=30 
## - Fold16: mtry=30 
## + Fold16: mtry=32 
## - Fold16: mtry=32 
## + Fold16: mtry=34 
## - Fold16: mtry=34 
## + Fold16: mtry=36 
## - Fold16: mtry=36 
## + Fold16: mtry=38 
## - Fold16: mtry=38 
## + Fold16: mtry=40 
## - Fold16: mtry=40 
## + Fold16: mtry=42 
## - Fold16: mtry=42 
## + Fold16: mtry=44 
## - Fold16: mtry=44 
## + Fold16: mtry=46 
## - Fold16: mtry=46 
## + Fold16: mtry=48 
## - Fold16: mtry=48 
## + Fold16: mtry=50 
## - Fold16: mtry=50 
## + Fold16: mtry=52 
## - Fold16: mtry=52 
## + Fold16: mtry=54 
## - Fold16: mtry=54 
## + Fold16: mtry=56 
## - Fold16: mtry=56 
## + Fold16: mtry=58 
## - Fold16: mtry=58 
## + Fold16: mtry=60 
## - Fold16: mtry=60 
## + Fold16: mtry=62 
## - Fold16: mtry=62 
## + Fold16: mtry=64 
## - Fold16: mtry=64 
## + Fold16: mtry=66 
## - Fold16: mtry=66 
## + Fold16: mtry=68 
## - Fold16: mtry=68 
## + Fold16: mtry=70 
## - Fold16: mtry=70 
## + Fold16: mtry=72 
## - Fold16: mtry=72 
## + Fold16: mtry=74 
## - Fold16: mtry=74 
## + Fold16: mtry=76 
## - Fold16: mtry=76 
## + Fold17: mtry= 2 
## - Fold17: mtry= 2 
## + Fold17: mtry= 4 
## - Fold17: mtry= 4 
## + Fold17: mtry= 6 
## - Fold17: mtry= 6 
## + Fold17: mtry= 8 
## - Fold17: mtry= 8 
## + Fold17: mtry=10 
## - Fold17: mtry=10 
## + Fold17: mtry=12 
## - Fold17: mtry=12 
## + Fold17: mtry=14 
## - Fold17: mtry=14 
## + Fold17: mtry=16 
## - Fold17: mtry=16 
## + Fold17: mtry=18 
## - Fold17: mtry=18 
## + Fold17: mtry=20 
## - Fold17: mtry=20 
## + Fold17: mtry=22 
## - Fold17: mtry=22 
## + Fold17: mtry=24 
## - Fold17: mtry=24 
## + Fold17: mtry=26 
## - Fold17: mtry=26 
## + Fold17: mtry=28 
## - Fold17: mtry=28 
## + Fold17: mtry=30 
## - Fold17: mtry=30 
## + Fold17: mtry=32 
## - Fold17: mtry=32 
## + Fold17: mtry=34 
## - Fold17: mtry=34 
## + Fold17: mtry=36 
## - Fold17: mtry=36 
## + Fold17: mtry=38 
## - Fold17: mtry=38 
## + Fold17: mtry=40 
## - Fold17: mtry=40 
## + Fold17: mtry=42 
## - Fold17: mtry=42 
## + Fold17: mtry=44 
## - Fold17: mtry=44 
## + Fold17: mtry=46 
## - Fold17: mtry=46 
## + Fold17: mtry=48 
## - Fold17: mtry=48 
## + Fold17: mtry=50 
## - Fold17: mtry=50 
## + Fold17: mtry=52 
## - Fold17: mtry=52 
## + Fold17: mtry=54 
## - Fold17: mtry=54 
## + Fold17: mtry=56 
## - Fold17: mtry=56 
## + Fold17: mtry=58 
## - Fold17: mtry=58 
## + Fold17: mtry=60 
## - Fold17: mtry=60 
## + Fold17: mtry=62 
## - Fold17: mtry=62 
## + Fold17: mtry=64 
## - Fold17: mtry=64 
## + Fold17: mtry=66 
## - Fold17: mtry=66 
## + Fold17: mtry=68 
## - Fold17: mtry=68 
## + Fold17: mtry=70 
## - Fold17: mtry=70 
## + Fold17: mtry=72 
## - Fold17: mtry=72 
## + Fold17: mtry=74 
## - Fold17: mtry=74 
## + Fold17: mtry=76 
## - Fold17: mtry=76 
## + Fold18: mtry= 2 
## - Fold18: mtry= 2 
## + Fold18: mtry= 4 
## - Fold18: mtry= 4 
## + Fold18: mtry= 6 
## - Fold18: mtry= 6 
## + Fold18: mtry= 8 
## - Fold18: mtry= 8 
## + Fold18: mtry=10 
## - Fold18: mtry=10 
## + Fold18: mtry=12 
## - Fold18: mtry=12 
## + Fold18: mtry=14 
## - Fold18: mtry=14 
## + Fold18: mtry=16 
## - Fold18: mtry=16 
## + Fold18: mtry=18 
## - Fold18: mtry=18 
## + Fold18: mtry=20 
## - Fold18: mtry=20 
## + Fold18: mtry=22 
## - Fold18: mtry=22 
## + Fold18: mtry=24 
## - Fold18: mtry=24 
## + Fold18: mtry=26 
## - Fold18: mtry=26 
## + Fold18: mtry=28 
## - Fold18: mtry=28 
## + Fold18: mtry=30 
## - Fold18: mtry=30 
## + Fold18: mtry=32 
## - Fold18: mtry=32 
## + Fold18: mtry=34 
## - Fold18: mtry=34 
## + Fold18: mtry=36 
## - Fold18: mtry=36 
## + Fold18: mtry=38 
## - Fold18: mtry=38 
## + Fold18: mtry=40 
## - Fold18: mtry=40 
## + Fold18: mtry=42 
## - Fold18: mtry=42 
## + Fold18: mtry=44 
## - Fold18: mtry=44 
## + Fold18: mtry=46 
## - Fold18: mtry=46 
## + Fold18: mtry=48 
## - Fold18: mtry=48 
## + Fold18: mtry=50 
## - Fold18: mtry=50 
## + Fold18: mtry=52 
## - Fold18: mtry=52 
## + Fold18: mtry=54 
## - Fold18: mtry=54 
## + Fold18: mtry=56 
## - Fold18: mtry=56 
## + Fold18: mtry=58 
## - Fold18: mtry=58 
## + Fold18: mtry=60 
## - Fold18: mtry=60 
## + Fold18: mtry=62 
## - Fold18: mtry=62 
## + Fold18: mtry=64 
## - Fold18: mtry=64 
## + Fold18: mtry=66 
## - Fold18: mtry=66 
## + Fold18: mtry=68 
## - Fold18: mtry=68 
## + Fold18: mtry=70 
## - Fold18: mtry=70 
## + Fold18: mtry=72 
## - Fold18: mtry=72 
## + Fold18: mtry=74 
## - Fold18: mtry=74 
## + Fold18: mtry=76 
## - Fold18: mtry=76 
## + Fold19: mtry= 2 
## - Fold19: mtry= 2 
## + Fold19: mtry= 4 
## - Fold19: mtry= 4 
## + Fold19: mtry= 6 
## - Fold19: mtry= 6 
## + Fold19: mtry= 8 
## - Fold19: mtry= 8 
## + Fold19: mtry=10 
## - Fold19: mtry=10 
## + Fold19: mtry=12 
## - Fold19: mtry=12 
## + Fold19: mtry=14 
## - Fold19: mtry=14 
## + Fold19: mtry=16 
## - Fold19: mtry=16 
## + Fold19: mtry=18 
## - Fold19: mtry=18 
## + Fold19: mtry=20 
## - Fold19: mtry=20 
## + Fold19: mtry=22 
## - Fold19: mtry=22 
## + Fold19: mtry=24 
## - Fold19: mtry=24 
## + Fold19: mtry=26 
## - Fold19: mtry=26 
## + Fold19: mtry=28 
## - Fold19: mtry=28 
## + Fold19: mtry=30 
## - Fold19: mtry=30 
## + Fold19: mtry=32 
## - Fold19: mtry=32 
## + Fold19: mtry=34 
## - Fold19: mtry=34 
## + Fold19: mtry=36 
## - Fold19: mtry=36 
## + Fold19: mtry=38 
## - Fold19: mtry=38 
## + Fold19: mtry=40 
## - Fold19: mtry=40 
## + Fold19: mtry=42 
## - Fold19: mtry=42 
## + Fold19: mtry=44 
## - Fold19: mtry=44 
## + Fold19: mtry=46 
## - Fold19: mtry=46 
## + Fold19: mtry=48 
## - Fold19: mtry=48 
## + Fold19: mtry=50 
## - Fold19: mtry=50 
## + Fold19: mtry=52 
## - Fold19: mtry=52 
## + Fold19: mtry=54 
## - Fold19: mtry=54 
## + Fold19: mtry=56 
## - Fold19: mtry=56 
## + Fold19: mtry=58 
## - Fold19: mtry=58 
## + Fold19: mtry=60 
## - Fold19: mtry=60 
## + Fold19: mtry=62 
## - Fold19: mtry=62 
## + Fold19: mtry=64 
## - Fold19: mtry=64 
## + Fold19: mtry=66 
## - Fold19: mtry=66 
## + Fold19: mtry=68 
## - Fold19: mtry=68 
## + Fold19: mtry=70 
## - Fold19: mtry=70 
## + Fold19: mtry=72 
## - Fold19: mtry=72 
## + Fold19: mtry=74 
## - Fold19: mtry=74 
## + Fold19: mtry=76 
## - Fold19: mtry=76 
## + Fold20: mtry= 2 
## - Fold20: mtry= 2 
## + Fold20: mtry= 4 
## - Fold20: mtry= 4 
## + Fold20: mtry= 6 
## - Fold20: mtry= 6 
## + Fold20: mtry= 8 
## - Fold20: mtry= 8 
## + Fold20: mtry=10 
## - Fold20: mtry=10 
## + Fold20: mtry=12 
## - Fold20: mtry=12 
## + Fold20: mtry=14 
## - Fold20: mtry=14 
## + Fold20: mtry=16 
## - Fold20: mtry=16 
## + Fold20: mtry=18 
## - Fold20: mtry=18 
## + Fold20: mtry=20 
## - Fold20: mtry=20 
## + Fold20: mtry=22 
## - Fold20: mtry=22 
## + Fold20: mtry=24 
## - Fold20: mtry=24 
## + Fold20: mtry=26 
## - Fold20: mtry=26 
## + Fold20: mtry=28 
## - Fold20: mtry=28 
## + Fold20: mtry=30 
## - Fold20: mtry=30 
## + Fold20: mtry=32 
## - Fold20: mtry=32 
## + Fold20: mtry=34 
## - Fold20: mtry=34 
## + Fold20: mtry=36 
## - Fold20: mtry=36 
## + Fold20: mtry=38 
## - Fold20: mtry=38 
## + Fold20: mtry=40 
## - Fold20: mtry=40 
## + Fold20: mtry=42 
## - Fold20: mtry=42 
## + Fold20: mtry=44 
## - Fold20: mtry=44 
## + Fold20: mtry=46 
## - Fold20: mtry=46 
## + Fold20: mtry=48 
## - Fold20: mtry=48 
## + Fold20: mtry=50 
## - Fold20: mtry=50 
## + Fold20: mtry=52 
## - Fold20: mtry=52 
## + Fold20: mtry=54 
## - Fold20: mtry=54 
## + Fold20: mtry=56 
## - Fold20: mtry=56 
## + Fold20: mtry=58 
## - Fold20: mtry=58 
## + Fold20: mtry=60 
## - Fold20: mtry=60 
## + Fold20: mtry=62 
## - Fold20: mtry=62 
## + Fold20: mtry=64 
## - Fold20: mtry=64 
## + Fold20: mtry=66 
## - Fold20: mtry=66 
## + Fold20: mtry=68 
## - Fold20: mtry=68 
## + Fold20: mtry=70 
## - Fold20: mtry=70 
## + Fold20: mtry=72 
## - Fold20: mtry=72 
## + Fold20: mtry=74 
## - Fold20: mtry=74 
## + Fold20: mtry=76 
## - Fold20: mtry=76 
## + Fold21: mtry= 2 
## - Fold21: mtry= 2 
## + Fold21: mtry= 4 
## - Fold21: mtry= 4 
## + Fold21: mtry= 6 
## - Fold21: mtry= 6 
## + Fold21: mtry= 8 
## - Fold21: mtry= 8 
## + Fold21: mtry=10 
## - Fold21: mtry=10 
## + Fold21: mtry=12 
## - Fold21: mtry=12 
## + Fold21: mtry=14 
## - Fold21: mtry=14 
## + Fold21: mtry=16 
## - Fold21: mtry=16 
## + Fold21: mtry=18 
## - Fold21: mtry=18 
## + Fold21: mtry=20 
## - Fold21: mtry=20 
## + Fold21: mtry=22 
## - Fold21: mtry=22 
## + Fold21: mtry=24 
## - Fold21: mtry=24 
## + Fold21: mtry=26 
## - Fold21: mtry=26 
## + Fold21: mtry=28 
## - Fold21: mtry=28 
## + Fold21: mtry=30 
## - Fold21: mtry=30 
## + Fold21: mtry=32 
## - Fold21: mtry=32 
## + Fold21: mtry=34 
## - Fold21: mtry=34 
## + Fold21: mtry=36 
## - Fold21: mtry=36 
## + Fold21: mtry=38 
## - Fold21: mtry=38 
## + Fold21: mtry=40 
## - Fold21: mtry=40 
## + Fold21: mtry=42 
## - Fold21: mtry=42 
## + Fold21: mtry=44 
## - Fold21: mtry=44 
## + Fold21: mtry=46 
## - Fold21: mtry=46 
## + Fold21: mtry=48 
## - Fold21: mtry=48 
## + Fold21: mtry=50 
## - Fold21: mtry=50 
## + Fold21: mtry=52 
## - Fold21: mtry=52 
## + Fold21: mtry=54 
## - Fold21: mtry=54 
## + Fold21: mtry=56 
## - Fold21: mtry=56 
## + Fold21: mtry=58 
## - Fold21: mtry=58 
## + Fold21: mtry=60 
## - Fold21: mtry=60 
## + Fold21: mtry=62 
## - Fold21: mtry=62 
## + Fold21: mtry=64 
## - Fold21: mtry=64 
## + Fold21: mtry=66 
## - Fold21: mtry=66 
## + Fold21: mtry=68 
## - Fold21: mtry=68 
## + Fold21: mtry=70 
## - Fold21: mtry=70 
## + Fold21: mtry=72 
## - Fold21: mtry=72 
## + Fold21: mtry=74 
## - Fold21: mtry=74 
## + Fold21: mtry=76 
## - Fold21: mtry=76 
## + Fold22: mtry= 2 
## - Fold22: mtry= 2 
## + Fold22: mtry= 4 
## - Fold22: mtry= 4 
## + Fold22: mtry= 6 
## - Fold22: mtry= 6 
## + Fold22: mtry= 8 
## - Fold22: mtry= 8 
## + Fold22: mtry=10 
## - Fold22: mtry=10 
## + Fold22: mtry=12 
## - Fold22: mtry=12 
## + Fold22: mtry=14 
## - Fold22: mtry=14 
## + Fold22: mtry=16 
## - Fold22: mtry=16 
## + Fold22: mtry=18 
## - Fold22: mtry=18 
## + Fold22: mtry=20 
## - Fold22: mtry=20 
## + Fold22: mtry=22 
## - Fold22: mtry=22 
## + Fold22: mtry=24 
## - Fold22: mtry=24 
## + Fold22: mtry=26 
## - Fold22: mtry=26 
## + Fold22: mtry=28 
## - Fold22: mtry=28 
## + Fold22: mtry=30 
## - Fold22: mtry=30 
## + Fold22: mtry=32 
## - Fold22: mtry=32 
## + Fold22: mtry=34 
## - Fold22: mtry=34 
## + Fold22: mtry=36 
## - Fold22: mtry=36 
## + Fold22: mtry=38 
## - Fold22: mtry=38 
## + Fold22: mtry=40 
## - Fold22: mtry=40 
## + Fold22: mtry=42 
## - Fold22: mtry=42 
## + Fold22: mtry=44 
## - Fold22: mtry=44 
## + Fold22: mtry=46 
## - Fold22: mtry=46 
## + Fold22: mtry=48 
## - Fold22: mtry=48 
## + Fold22: mtry=50 
## - Fold22: mtry=50 
## + Fold22: mtry=52 
## - Fold22: mtry=52 
## + Fold22: mtry=54 
## - Fold22: mtry=54 
## + Fold22: mtry=56 
## - Fold22: mtry=56 
## + Fold22: mtry=58 
## - Fold22: mtry=58 
## + Fold22: mtry=60 
## - Fold22: mtry=60 
## + Fold22: mtry=62 
## - Fold22: mtry=62 
## + Fold22: mtry=64 
## - Fold22: mtry=64 
## + Fold22: mtry=66 
## - Fold22: mtry=66 
## + Fold22: mtry=68 
## - Fold22: mtry=68 
## + Fold22: mtry=70 
## - Fold22: mtry=70 
## + Fold22: mtry=72 
## - Fold22: mtry=72 
## + Fold22: mtry=74 
## - Fold22: mtry=74 
## + Fold22: mtry=76 
## - Fold22: mtry=76 
## + Fold23: mtry= 2 
## - Fold23: mtry= 2 
## + Fold23: mtry= 4 
## - Fold23: mtry= 4 
## + Fold23: mtry= 6 
## - Fold23: mtry= 6 
## + Fold23: mtry= 8 
## - Fold23: mtry= 8 
## + Fold23: mtry=10 
## - Fold23: mtry=10 
## + Fold23: mtry=12 
## - Fold23: mtry=12 
## + Fold23: mtry=14 
## - Fold23: mtry=14 
## + Fold23: mtry=16 
## - Fold23: mtry=16 
## + Fold23: mtry=18 
## - Fold23: mtry=18 
## + Fold23: mtry=20 
## - Fold23: mtry=20 
## + Fold23: mtry=22 
## - Fold23: mtry=22 
## + Fold23: mtry=24 
## - Fold23: mtry=24 
## + Fold23: mtry=26 
## - Fold23: mtry=26 
## + Fold23: mtry=28 
## - Fold23: mtry=28 
## + Fold23: mtry=30 
## - Fold23: mtry=30 
## + Fold23: mtry=32 
## - Fold23: mtry=32 
## + Fold23: mtry=34 
## - Fold23: mtry=34 
## + Fold23: mtry=36 
## - Fold23: mtry=36 
## + Fold23: mtry=38 
## - Fold23: mtry=38 
## + Fold23: mtry=40 
## - Fold23: mtry=40 
## + Fold23: mtry=42 
## - Fold23: mtry=42 
## + Fold23: mtry=44 
## - Fold23: mtry=44 
## + Fold23: mtry=46 
## - Fold23: mtry=46 
## + Fold23: mtry=48 
## - Fold23: mtry=48 
## + Fold23: mtry=50 
## - Fold23: mtry=50 
## + Fold23: mtry=52 
## - Fold23: mtry=52 
## + Fold23: mtry=54 
## - Fold23: mtry=54 
## + Fold23: mtry=56 
## - Fold23: mtry=56 
## + Fold23: mtry=58 
## - Fold23: mtry=58 
## + Fold23: mtry=60 
## - Fold23: mtry=60 
## + Fold23: mtry=62 
## - Fold23: mtry=62 
## + Fold23: mtry=64 
## - Fold23: mtry=64 
## + Fold23: mtry=66 
## - Fold23: mtry=66 
## + Fold23: mtry=68 
## - Fold23: mtry=68 
## + Fold23: mtry=70 
## - Fold23: mtry=70 
## + Fold23: mtry=72 
## - Fold23: mtry=72 
## + Fold23: mtry=74 
## - Fold23: mtry=74 
## + Fold23: mtry=76 
## - Fold23: mtry=76 
## + Fold24: mtry= 2 
## - Fold24: mtry= 2 
## + Fold24: mtry= 4 
## - Fold24: mtry= 4 
## + Fold24: mtry= 6 
## - Fold24: mtry= 6 
## + Fold24: mtry= 8 
## - Fold24: mtry= 8 
## + Fold24: mtry=10 
## - Fold24: mtry=10 
## + Fold24: mtry=12 
## - Fold24: mtry=12 
## + Fold24: mtry=14 
## - Fold24: mtry=14 
## + Fold24: mtry=16 
## - Fold24: mtry=16 
## + Fold24: mtry=18 
## - Fold24: mtry=18 
## + Fold24: mtry=20 
## - Fold24: mtry=20 
## + Fold24: mtry=22 
## - Fold24: mtry=22 
## + Fold24: mtry=24 
## - Fold24: mtry=24 
## + Fold24: mtry=26 
## - Fold24: mtry=26 
## + Fold24: mtry=28 
## - Fold24: mtry=28 
## + Fold24: mtry=30 
## - Fold24: mtry=30 
## + Fold24: mtry=32 
## - Fold24: mtry=32 
## + Fold24: mtry=34 
## - Fold24: mtry=34 
## + Fold24: mtry=36 
## - Fold24: mtry=36 
## + Fold24: mtry=38 
## - Fold24: mtry=38 
## + Fold24: mtry=40 
## - Fold24: mtry=40 
## + Fold24: mtry=42 
## - Fold24: mtry=42 
## + Fold24: mtry=44 
## - Fold24: mtry=44 
## + Fold24: mtry=46 
## - Fold24: mtry=46 
## + Fold24: mtry=48 
## - Fold24: mtry=48 
## + Fold24: mtry=50 
## - Fold24: mtry=50 
## + Fold24: mtry=52 
## - Fold24: mtry=52 
## + Fold24: mtry=54 
## - Fold24: mtry=54 
## + Fold24: mtry=56 
## - Fold24: mtry=56 
## + Fold24: mtry=58 
## - Fold24: mtry=58 
## + Fold24: mtry=60 
## - Fold24: mtry=60 
## + Fold24: mtry=62 
## - Fold24: mtry=62 
## + Fold24: mtry=64 
## - Fold24: mtry=64 
## + Fold24: mtry=66 
## - Fold24: mtry=66 
## + Fold24: mtry=68 
## - Fold24: mtry=68 
## + Fold24: mtry=70 
## - Fold24: mtry=70 
## + Fold24: mtry=72 
## - Fold24: mtry=72 
## + Fold24: mtry=74 
## - Fold24: mtry=74 
## + Fold24: mtry=76 
## - Fold24: mtry=76 
## + Fold25: mtry= 2 
## - Fold25: mtry= 2 
## + Fold25: mtry= 4 
## - Fold25: mtry= 4 
## + Fold25: mtry= 6 
## - Fold25: mtry= 6 
## + Fold25: mtry= 8 
## - Fold25: mtry= 8 
## + Fold25: mtry=10 
## - Fold25: mtry=10 
## + Fold25: mtry=12 
## - Fold25: mtry=12 
## + Fold25: mtry=14 
## - Fold25: mtry=14 
## + Fold25: mtry=16 
## - Fold25: mtry=16 
## + Fold25: mtry=18 
## - Fold25: mtry=18 
## + Fold25: mtry=20 
## - Fold25: mtry=20 
## + Fold25: mtry=22 
## - Fold25: mtry=22 
## + Fold25: mtry=24 
## - Fold25: mtry=24 
## + Fold25: mtry=26 
## - Fold25: mtry=26 
## + Fold25: mtry=28 
## - Fold25: mtry=28 
## + Fold25: mtry=30 
## - Fold25: mtry=30 
## + Fold25: mtry=32 
## - Fold25: mtry=32 
## + Fold25: mtry=34 
## - Fold25: mtry=34 
## + Fold25: mtry=36 
## - Fold25: mtry=36 
## + Fold25: mtry=38 
## - Fold25: mtry=38 
## + Fold25: mtry=40 
## - Fold25: mtry=40 
## + Fold25: mtry=42 
## - Fold25: mtry=42 
## + Fold25: mtry=44 
## - Fold25: mtry=44 
## + Fold25: mtry=46 
## - Fold25: mtry=46 
## + Fold25: mtry=48 
## - Fold25: mtry=48 
## + Fold25: mtry=50 
## - Fold25: mtry=50 
## + Fold25: mtry=52 
## - Fold25: mtry=52 
## + Fold25: mtry=54 
## - Fold25: mtry=54 
## + Fold25: mtry=56 
## - Fold25: mtry=56 
## + Fold25: mtry=58 
## - Fold25: mtry=58 
## + Fold25: mtry=60 
## - Fold25: mtry=60 
## + Fold25: mtry=62 
## - Fold25: mtry=62 
## + Fold25: mtry=64 
## - Fold25: mtry=64 
## + Fold25: mtry=66 
## - Fold25: mtry=66 
## + Fold25: mtry=68 
## - Fold25: mtry=68 
## + Fold25: mtry=70 
## - Fold25: mtry=70 
## + Fold25: mtry=72 
## - Fold25: mtry=72 
## + Fold25: mtry=74 
## - Fold25: mtry=74 
## + Fold25: mtry=76 
## - Fold25: mtry=76 
## + Fold26: mtry= 2 
## - Fold26: mtry= 2 
## + Fold26: mtry= 4 
## - Fold26: mtry= 4 
## + Fold26: mtry= 6 
## - Fold26: mtry= 6 
## + Fold26: mtry= 8 
## - Fold26: mtry= 8 
## + Fold26: mtry=10 
## - Fold26: mtry=10 
## + Fold26: mtry=12 
## - Fold26: mtry=12 
## + Fold26: mtry=14 
## - Fold26: mtry=14 
## + Fold26: mtry=16 
## - Fold26: mtry=16 
## + Fold26: mtry=18 
## - Fold26: mtry=18 
## + Fold26: mtry=20 
## - Fold26: mtry=20 
## + Fold26: mtry=22 
## - Fold26: mtry=22 
## + Fold26: mtry=24 
## - Fold26: mtry=24 
## + Fold26: mtry=26 
## - Fold26: mtry=26 
## + Fold26: mtry=28 
## - Fold26: mtry=28 
## + Fold26: mtry=30 
## - Fold26: mtry=30 
## + Fold26: mtry=32 
## - Fold26: mtry=32 
## + Fold26: mtry=34 
## - Fold26: mtry=34 
## + Fold26: mtry=36 
## - Fold26: mtry=36 
## + Fold26: mtry=38 
## - Fold26: mtry=38 
## + Fold26: mtry=40 
## - Fold26: mtry=40 
## + Fold26: mtry=42 
## - Fold26: mtry=42 
## + Fold26: mtry=44 
## - Fold26: mtry=44 
## + Fold26: mtry=46 
## - Fold26: mtry=46 
## + Fold26: mtry=48 
## - Fold26: mtry=48 
## + Fold26: mtry=50 
## - Fold26: mtry=50 
## + Fold26: mtry=52 
## - Fold26: mtry=52 
## + Fold26: mtry=54 
## - Fold26: mtry=54 
## + Fold26: mtry=56 
## - Fold26: mtry=56 
## + Fold26: mtry=58 
## - Fold26: mtry=58 
## + Fold26: mtry=60 
## - Fold26: mtry=60 
## + Fold26: mtry=62 
## - Fold26: mtry=62 
## + Fold26: mtry=64 
## - Fold26: mtry=64 
## + Fold26: mtry=66 
## - Fold26: mtry=66 
## + Fold26: mtry=68 
## - Fold26: mtry=68 
## + Fold26: mtry=70 
## - Fold26: mtry=70 
## + Fold26: mtry=72 
## - Fold26: mtry=72 
## + Fold26: mtry=74 
## - Fold26: mtry=74 
## + Fold26: mtry=76 
## - Fold26: mtry=76 
## + Fold27: mtry= 2 
## - Fold27: mtry= 2 
## + Fold27: mtry= 4 
## - Fold27: mtry= 4 
## + Fold27: mtry= 6 
## - Fold27: mtry= 6 
## + Fold27: mtry= 8 
## - Fold27: mtry= 8 
## + Fold27: mtry=10 
## - Fold27: mtry=10 
## + Fold27: mtry=12 
## - Fold27: mtry=12 
## + Fold27: mtry=14 
## - Fold27: mtry=14 
## + Fold27: mtry=16 
## - Fold27: mtry=16 
## + Fold27: mtry=18 
## - Fold27: mtry=18 
## + Fold27: mtry=20 
## - Fold27: mtry=20 
## + Fold27: mtry=22 
## - Fold27: mtry=22 
## + Fold27: mtry=24 
## - Fold27: mtry=24 
## + Fold27: mtry=26 
## - Fold27: mtry=26 
## + Fold27: mtry=28 
## - Fold27: mtry=28 
## + Fold27: mtry=30 
## - Fold27: mtry=30 
## + Fold27: mtry=32 
## - Fold27: mtry=32 
## + Fold27: mtry=34 
## - Fold27: mtry=34 
## + Fold27: mtry=36 
## - Fold27: mtry=36 
## + Fold27: mtry=38 
## - Fold27: mtry=38 
## + Fold27: mtry=40 
## - Fold27: mtry=40 
## + Fold27: mtry=42 
## - Fold27: mtry=42 
## + Fold27: mtry=44 
## - Fold27: mtry=44 
## + Fold27: mtry=46 
## - Fold27: mtry=46 
## + Fold27: mtry=48 
## - Fold27: mtry=48 
## + Fold27: mtry=50 
## - Fold27: mtry=50 
## + Fold27: mtry=52 
## - Fold27: mtry=52 
## + Fold27: mtry=54 
## - Fold27: mtry=54 
## + Fold27: mtry=56 
## - Fold27: mtry=56 
## + Fold27: mtry=58 
## - Fold27: mtry=58 
## + Fold27: mtry=60 
## - Fold27: mtry=60 
## + Fold27: mtry=62 
## - Fold27: mtry=62 
## + Fold27: mtry=64 
## - Fold27: mtry=64 
## + Fold27: mtry=66 
## - Fold27: mtry=66 
## + Fold27: mtry=68 
## - Fold27: mtry=68 
## + Fold27: mtry=70 
## - Fold27: mtry=70 
## + Fold27: mtry=72 
## - Fold27: mtry=72 
## + Fold27: mtry=74 
## - Fold27: mtry=74 
## + Fold27: mtry=76 
## - Fold27: mtry=76 
## + Fold28: mtry= 2 
## - Fold28: mtry= 2 
## + Fold28: mtry= 4 
## - Fold28: mtry= 4 
## + Fold28: mtry= 6 
## - Fold28: mtry= 6 
## + Fold28: mtry= 8 
## - Fold28: mtry= 8 
## + Fold28: mtry=10 
## - Fold28: mtry=10 
## + Fold28: mtry=12 
## - Fold28: mtry=12 
## + Fold28: mtry=14 
## - Fold28: mtry=14 
## + Fold28: mtry=16 
## - Fold28: mtry=16 
## + Fold28: mtry=18 
## - Fold28: mtry=18 
## + Fold28: mtry=20 
## - Fold28: mtry=20 
## + Fold28: mtry=22 
## - Fold28: mtry=22 
## + Fold28: mtry=24 
## - Fold28: mtry=24 
## + Fold28: mtry=26 
## - Fold28: mtry=26 
## + Fold28: mtry=28 
## - Fold28: mtry=28 
## + Fold28: mtry=30 
## - Fold28: mtry=30 
## + Fold28: mtry=32 
## - Fold28: mtry=32 
## + Fold28: mtry=34 
## - Fold28: mtry=34 
## + Fold28: mtry=36 
## - Fold28: mtry=36 
## + Fold28: mtry=38 
## - Fold28: mtry=38 
## + Fold28: mtry=40 
## - Fold28: mtry=40 
## + Fold28: mtry=42 
## - Fold28: mtry=42 
## + Fold28: mtry=44 
## - Fold28: mtry=44 
## + Fold28: mtry=46 
## - Fold28: mtry=46 
## + Fold28: mtry=48 
## - Fold28: mtry=48 
## + Fold28: mtry=50 
## - Fold28: mtry=50 
## + Fold28: mtry=52 
## - Fold28: mtry=52 
## + Fold28: mtry=54 
## - Fold28: mtry=54 
## + Fold28: mtry=56 
## - Fold28: mtry=56 
## + Fold28: mtry=58 
## - Fold28: mtry=58 
## + Fold28: mtry=60 
## - Fold28: mtry=60 
## + Fold28: mtry=62 
## - Fold28: mtry=62 
## + Fold28: mtry=64 
## - Fold28: mtry=64 
## + Fold28: mtry=66 
## - Fold28: mtry=66 
## + Fold28: mtry=68 
## - Fold28: mtry=68 
## + Fold28: mtry=70 
## - Fold28: mtry=70 
## + Fold28: mtry=72 
## - Fold28: mtry=72 
## + Fold28: mtry=74 
## - Fold28: mtry=74 
## + Fold28: mtry=76 
## - Fold28: mtry=76 
## Aggregating results
## Selecting tuning parameters
## Fitting mtry = 74 on full training set
# View results
print(rf_model)
## Random Forest 
## 
## 28 samples
## 77 predictors
## 
## Pre-processing: scaled (77), centered (77) 
## Resampling: Leave-One-Out Cross-Validation 
## Summary of sample sizes: 27, 27, 27, 27, 27, 27, ... 
## Resampling results across tuning parameters:
## 
##   mtry  RMSE       Rsquared   MAE       
##    2    0.1340677  0.7027724  0.10611360
##    4    0.1223014  0.7525156  0.09685893
##    6    0.1185285  0.7394641  0.09662985
##    8    0.1131596  0.7621642  0.09156987
##   10    0.1147484  0.7477514  0.09328456
##   12    0.1131942  0.7511312  0.09323591
##   14    0.1113480  0.7590494  0.09089457
##   16    0.1070755  0.7830346  0.08778009
##   18    0.1049438  0.7868920  0.08733542
##   20    0.1088106  0.7573214  0.09182430
##   22    0.1076286  0.7647823  0.08962344
##   24    0.1042948  0.7816854  0.08719319
##   26    0.1063151  0.7688885  0.08880109
##   28    0.1037394  0.7854538  0.08656739
##   30    0.1063075  0.7701789  0.08995771
##   32    0.1047680  0.7739923  0.08822147
##   34    0.1039211  0.7787565  0.08775866
##   36    0.1042549  0.7797645  0.08812937
##   38    0.1036824  0.7820748  0.08713922
##   40    0.1033886  0.7819013  0.08709370
##   42    0.1028162  0.7824084  0.08807994
##   44    0.1037518  0.7781091  0.08836165
##   46    0.1041355  0.7719966  0.08842543
##   48    0.1042260  0.7763559  0.08846454
##   50    0.1044087  0.7721682  0.08833346
##   52    0.1034126  0.7780116  0.08811085
##   54    0.1038088  0.7718965  0.08782083
##   56    0.1043292  0.7721859  0.08976233
##   58    0.1034437  0.7790495  0.08847410
##   60    0.1030409  0.7777514  0.08812578
##   62    0.1037524  0.7750573  0.08962625
##   64    0.1033621  0.7761743  0.08880371
##   66    0.1057159  0.7629484  0.09026237
##   68    0.1034075  0.7752889  0.08807459
##   70    0.1020962  0.7809881  0.08736141
##   72    0.1032705  0.7769025  0.08901812
##   74    0.1018470  0.7834390  0.08764772
##   76    0.1052073  0.7652970  0.09070107
## 
## RMSE was used to select the optimal model using the smallest value.
## The final value used for the model was mtry = 74.
plot(rf_model)  # Plot performance across hyperparameters

varImpPlot(rf_model$finalModel)  # Plot variable importance

Gradient boosting

gbm_grid <- expand.grid(
  n.trees = c(50, 100, 200),           # Fewer trees
  interaction.depth = c(1, 2, 3),      # Much smaller tree depth
  shrinkage = c(0.01, 0.05, 0.1),      # Keep these values
  n.minobsinnode = c(1, 3, 5)          # Smaller minimum observations
)

gbm_model <- train(
  mean_trans_docs ~ ., 
  data = data_aggr, 
  method = "gbm",
  preProc = c('scale', 'center'),
  trControl = control,
  tuneGrid = gbm_grid)
## + Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0006
##      2        0.0434             nan     0.0100    0.0003
##      3        0.0426             nan     0.0100    0.0006
##      4        0.0421             nan     0.0100    0.0005
##      5        0.0416             nan     0.0100    0.0002
##      6        0.0411             nan     0.0100    0.0005
##      7        0.0407             nan     0.0100    0.0001
##      8        0.0403             nan     0.0100    0.0003
##      9        0.0398             nan     0.0100    0.0003
##     10        0.0394             nan     0.0100    0.0005
##     20        0.0350             nan     0.0100    0.0003
##     40        0.0281             nan     0.0100    0.0003
##     60        0.0228             nan     0.0100    0.0002
##     80        0.0185             nan     0.0100    0.0001
##    100        0.0153             nan     0.0100    0.0001
##    120        0.0129             nan     0.0100    0.0001
##    140        0.0109             nan     0.0100    0.0001
##    160        0.0091             nan     0.0100    0.0001
##    180        0.0076             nan     0.0100    0.0001
##    200        0.0065             nan     0.0100    0.0001
## 
## - Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0441             nan     0.0100   -0.0001
##      2        0.0436             nan     0.0100    0.0005
##      3        0.0433             nan     0.0100    0.0003
##      4        0.0427             nan     0.0100    0.0005
##      5        0.0423             nan     0.0100    0.0003
##      6        0.0417             nan     0.0100    0.0003
##      7        0.0411             nan     0.0100    0.0004
##      8        0.0405             nan     0.0100    0.0004
##      9        0.0400             nan     0.0100   -0.0000
##     10        0.0396             nan     0.0100    0.0004
##     20        0.0349             nan     0.0100    0.0003
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0220             nan     0.0100    0.0002
##     80        0.0177             nan     0.0100    0.0002
##    100        0.0143             nan     0.0100    0.0001
##    120        0.0117             nan     0.0100    0.0000
##    140        0.0096             nan     0.0100    0.0000
##    160        0.0080             nan     0.0100    0.0000
##    180        0.0068             nan     0.0100    0.0000
##    200        0.0057             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0440             nan     0.0100    0.0004
##      2        0.0434             nan     0.0100    0.0006
##      3        0.0429             nan     0.0100    0.0005
##      4        0.0423             nan     0.0100    0.0006
##      5        0.0418             nan     0.0100    0.0005
##      6        0.0413             nan     0.0100    0.0005
##      7        0.0408             nan     0.0100    0.0005
##      8        0.0404             nan     0.0100    0.0005
##      9        0.0401             nan     0.0100   -0.0000
##     10        0.0395             nan     0.0100    0.0006
##     20        0.0352             nan     0.0100    0.0005
##     40        0.0281             nan     0.0100    0.0004
##     60        0.0229             nan     0.0100    0.0002
##     80        0.0192             nan     0.0100    0.0002
##    100        0.0164             nan     0.0100    0.0000
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0120             nan     0.0100    0.0000
##    160        0.0104             nan     0.0100    0.0000
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0003
##      2        0.0434             nan     0.0100    0.0003
##      3        0.0426             nan     0.0100    0.0006
##      4        0.0418             nan     0.0100    0.0007
##      5        0.0411             nan     0.0100    0.0008
##      6        0.0404             nan     0.0100    0.0008
##      7        0.0398             nan     0.0100    0.0003
##      8        0.0392             nan     0.0100    0.0003
##      9        0.0385             nan     0.0100    0.0006
##     10        0.0378             nan     0.0100    0.0004
##     20        0.0330             nan     0.0100    0.0003
##     40        0.0245             nan     0.0100    0.0000
##     60        0.0186             nan     0.0100    0.0000
##     80        0.0143             nan     0.0100    0.0002
##    100        0.0111             nan     0.0100    0.0000
##    120        0.0086             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0001
##    160        0.0056             nan     0.0100    0.0001
##    180        0.0045             nan     0.0100    0.0000
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0004
##      2        0.0434             nan     0.0100    0.0004
##      3        0.0429             nan     0.0100    0.0005
##      4        0.0423             nan     0.0100    0.0007
##      5        0.0415             nan     0.0100    0.0006
##      6        0.0407             nan     0.0100    0.0004
##      7        0.0404             nan     0.0100    0.0001
##      8        0.0398             nan     0.0100    0.0004
##      9        0.0392             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100    0.0006
##     20        0.0337             nan     0.0100    0.0003
##     40        0.0257             nan     0.0100    0.0001
##     60        0.0196             nan     0.0100    0.0001
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0101             nan     0.0100    0.0000
##    140        0.0082             nan     0.0100    0.0000
##    160        0.0067             nan     0.0100    0.0000
##    180        0.0054             nan     0.0100   -0.0000
##    200        0.0045             nan     0.0100   -0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0004
##      2        0.0434             nan     0.0100    0.0006
##      3        0.0429             nan     0.0100    0.0006
##      4        0.0424             nan     0.0100    0.0004
##      5        0.0419             nan     0.0100    0.0001
##      6        0.0415             nan     0.0100    0.0003
##      7        0.0414             nan     0.0100   -0.0003
##      8        0.0407             nan     0.0100    0.0005
##      9        0.0404             nan     0.0100    0.0003
##     10        0.0398             nan     0.0100    0.0006
##     20        0.0351             nan     0.0100    0.0005
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0157             nan     0.0100    0.0001
##    120        0.0134             nan     0.0100    0.0001
##    140        0.0118             nan     0.0100    0.0000
##    160        0.0106             nan     0.0100    0.0000
##    180        0.0094             nan     0.0100   -0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0008
##      2        0.0433             nan     0.0100    0.0004
##      3        0.0428             nan     0.0100    0.0005
##      4        0.0420             nan     0.0100    0.0006
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0005
##      7        0.0399             nan     0.0100    0.0002
##      8        0.0393             nan     0.0100    0.0005
##      9        0.0386             nan     0.0100    0.0008
##     10        0.0382             nan     0.0100    0.0003
##     20        0.0323             nan     0.0100    0.0003
##     40        0.0247             nan     0.0100    0.0002
##     60        0.0184             nan     0.0100    0.0003
##     80        0.0139             nan     0.0100    0.0002
##    100        0.0105             nan     0.0100    0.0002
##    120        0.0083             nan     0.0100    0.0000
##    140        0.0062             nan     0.0100    0.0001
##    160        0.0048             nan     0.0100    0.0000
##    180        0.0039             nan     0.0100    0.0000
##    200        0.0031             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0432             nan     0.0100    0.0007
##      3        0.0424             nan     0.0100    0.0007
##      4        0.0418             nan     0.0100    0.0006
##      5        0.0411             nan     0.0100    0.0006
##      6        0.0408             nan     0.0100   -0.0001
##      7        0.0403             nan     0.0100    0.0004
##      8        0.0399             nan     0.0100    0.0004
##      9        0.0392             nan     0.0100    0.0005
##     10        0.0385             nan     0.0100    0.0007
##     20        0.0332             nan     0.0100    0.0003
##     40        0.0254             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0002
##     80        0.0150             nan     0.0100    0.0001
##    100        0.0115             nan     0.0100    0.0001
##    120        0.0093             nan     0.0100    0.0000
##    140        0.0074             nan     0.0100    0.0000
##    160        0.0059             nan     0.0100   -0.0000
##    180        0.0049             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100   -0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0433             nan     0.0100    0.0003
##      3        0.0428             nan     0.0100    0.0004
##      4        0.0423             nan     0.0100    0.0006
##      5        0.0417             nan     0.0100    0.0003
##      6        0.0412             nan     0.0100    0.0004
##      7        0.0407             nan     0.0100    0.0005
##      8        0.0404             nan     0.0100    0.0000
##      9        0.0399             nan     0.0100    0.0005
##     10        0.0394             nan     0.0100    0.0005
##     20        0.0353             nan     0.0100    0.0003
##     40        0.0283             nan     0.0100    0.0002
##     60        0.0232             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0157             nan     0.0100    0.0000
##    120        0.0132             nan     0.0100   -0.0000
##    140        0.0113             nan     0.0100    0.0001
##    160        0.0096             nan     0.0100    0.0000
##    180        0.0086             nan     0.0100    0.0000
##    200        0.0075             nan     0.0100    0.0000
## 
## - Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0027
##      2        0.0392             nan     0.0500    0.0014
##      3        0.0372             nan     0.0500    0.0019
##      4        0.0344             nan     0.0500    0.0021
##      5        0.0317             nan     0.0500    0.0022
##      6        0.0297             nan     0.0500    0.0021
##      7        0.0281             nan     0.0500    0.0017
##      8        0.0265             nan     0.0500    0.0016
##      9        0.0252             nan     0.0500    0.0014
##     10        0.0234             nan     0.0500    0.0011
##     20        0.0140             nan     0.0500    0.0006
##     40        0.0060             nan     0.0500    0.0002
##     60        0.0033             nan     0.0500    0.0001
##     80        0.0019             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0030
##      2        0.0386             nan     0.0500    0.0030
##      3        0.0360             nan     0.0500    0.0026
##      4        0.0335             nan     0.0500    0.0018
##      5        0.0312             nan     0.0500    0.0016
##      6        0.0295             nan     0.0500    0.0013
##      7        0.0274             nan     0.0500    0.0019
##      8        0.0262             nan     0.0500    0.0010
##      9        0.0244             nan     0.0500    0.0009
##     10        0.0232             nan     0.0500    0.0012
##     20        0.0140             nan     0.0500   -0.0001
##     40        0.0062             nan     0.0500    0.0001
##     60        0.0031             nan     0.0500    0.0000
##     80        0.0018             nan     0.0500    0.0000
##    100        0.0011             nan     0.0500    0.0000
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0004             nan     0.0500   -0.0000
##    180        0.0003             nan     0.0500    0.0000
##    200        0.0002             nan     0.0500    0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0028
##      2        0.0377             nan     0.0500    0.0028
##      3        0.0357             nan     0.0500    0.0014
##      4        0.0340             nan     0.0500    0.0013
##      5        0.0314             nan     0.0500    0.0022
##      6        0.0292             nan     0.0500    0.0009
##      7        0.0286             nan     0.0500   -0.0005
##      8        0.0266             nan     0.0500    0.0012
##      9        0.0256             nan     0.0500    0.0006
##     10        0.0241             nan     0.0500    0.0004
##     20        0.0159             nan     0.0500    0.0008
##     40        0.0083             nan     0.0500    0.0002
##     60        0.0048             nan     0.0500   -0.0001
##     80        0.0029             nan     0.0500    0.0001
##    100        0.0018             nan     0.0500    0.0000
##    120        0.0012             nan     0.0500    0.0000
##    140        0.0008             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500    0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0006
##      2        0.0395             nan     0.0500   -0.0000
##      3        0.0368             nan     0.0500    0.0019
##      4        0.0342             nan     0.0500    0.0014
##      5        0.0315             nan     0.0500    0.0023
##      6        0.0295             nan     0.0500    0.0011
##      7        0.0277             nan     0.0500    0.0017
##      8        0.0256             nan     0.0500    0.0011
##      9        0.0238             nan     0.0500    0.0014
##     10        0.0225             nan     0.0500    0.0009
##     20        0.0125             nan     0.0500    0.0008
##     40        0.0038             nan     0.0500   -0.0000
##     60        0.0014             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.0500    0.0021
##      2        0.0388             nan     0.0500    0.0016
##      3        0.0361             nan     0.0500    0.0015
##      4        0.0335             nan     0.0500    0.0027
##      5        0.0318             nan     0.0500    0.0014
##      6        0.0301             nan     0.0500    0.0010
##      7        0.0281             nan     0.0500    0.0019
##      8        0.0265             nan     0.0500   -0.0001
##      9        0.0252             nan     0.0500    0.0005
##     10        0.0232             nan     0.0500    0.0015
##     20        0.0127             nan     0.0500    0.0006
##     40        0.0046             nan     0.0500    0.0000
##     60        0.0021             nan     0.0500   -0.0001
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.0500    0.0009
##      2        0.0381             nan     0.0500    0.0021
##      3        0.0363             nan     0.0500    0.0006
##      4        0.0346             nan     0.0500    0.0007
##      5        0.0333             nan     0.0500    0.0006
##      6        0.0315             nan     0.0500    0.0012
##      7        0.0296             nan     0.0500    0.0021
##      8        0.0275             nan     0.0500    0.0012
##      9        0.0261             nan     0.0500    0.0015
##     10        0.0251             nan     0.0500    0.0009
##     20        0.0158             nan     0.0500    0.0004
##     40        0.0081             nan     0.0500    0.0001
##     60        0.0047             nan     0.0500    0.0000
##     80        0.0031             nan     0.0500   -0.0000
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500   -0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0023
##      2        0.0387             nan     0.0500    0.0029
##      3        0.0377             nan     0.0500   -0.0004
##      4        0.0352             nan     0.0500    0.0028
##      5        0.0326             nan     0.0500    0.0022
##      6        0.0298             nan     0.0500    0.0015
##      7        0.0273             nan     0.0500    0.0031
##      8        0.0252             nan     0.0500    0.0009
##      9        0.0235             nan     0.0500    0.0015
##     10        0.0221             nan     0.0500    0.0012
##     20        0.0108             nan     0.0500    0.0003
##     40        0.0030             nan     0.0500    0.0001
##     60        0.0011             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0027
##      2        0.0382             nan     0.0500    0.0029
##      3        0.0350             nan     0.0500    0.0018
##      4        0.0336             nan     0.0500    0.0011
##      5        0.0321             nan     0.0500    0.0020
##      6        0.0300             nan     0.0500    0.0019
##      7        0.0276             nan     0.0500    0.0016
##      8        0.0252             nan     0.0500    0.0012
##      9        0.0243             nan     0.0500    0.0005
##     10        0.0221             nan     0.0500    0.0011
##     20        0.0122             nan     0.0500    0.0005
##     40        0.0040             nan     0.0500    0.0000
##     60        0.0021             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0500    0.0014
##      2        0.0401             nan     0.0500    0.0022
##      3        0.0378             nan     0.0500    0.0015
##      4        0.0348             nan     0.0500    0.0027
##      5        0.0337             nan     0.0500    0.0002
##      6        0.0326             nan     0.0500    0.0003
##      7        0.0308             nan     0.0500    0.0005
##      8        0.0290             nan     0.0500    0.0015
##      9        0.0280             nan     0.0500    0.0004
##     10        0.0265             nan     0.0500    0.0009
##     20        0.0160             nan     0.0500    0.0005
##     40        0.0084             nan     0.0500   -0.0001
##     60        0.0049             nan     0.0500   -0.0000
##     80        0.0031             nan     0.0500    0.0000
##    100        0.0019             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0007             nan     0.0500    0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.1000    0.0063
##      2        0.0338             nan     0.1000    0.0050
##      3        0.0287             nan     0.1000    0.0043
##      4        0.0248             nan     0.1000    0.0028
##      5        0.0234             nan     0.1000    0.0011
##      6        0.0201             nan     0.1000    0.0025
##      7        0.0193             nan     0.1000   -0.0002
##      8        0.0179             nan     0.1000    0.0010
##      9        0.0155             nan     0.1000    0.0016
##     10        0.0130             nan     0.1000    0.0032
##     20        0.0058             nan     0.1000    0.0005
##     40        0.0015             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.1000    0.0025
##      2        0.0349             nan     0.1000    0.0044
##      3        0.0303             nan     0.1000    0.0031
##      4        0.0278             nan     0.1000    0.0022
##      5        0.0254             nan     0.1000    0.0012
##      6        0.0231             nan     0.1000    0.0012
##      7        0.0211             nan     0.1000    0.0013
##      8        0.0189             nan     0.1000    0.0015
##      9        0.0174             nan     0.1000    0.0003
##     10        0.0157             nan     0.1000    0.0021
##     20        0.0068             nan     0.1000    0.0002
##     40        0.0022             nan     0.1000    0.0000
##     60        0.0009             nan     0.1000    0.0000
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.1000    0.0038
##      2        0.0361             nan     0.1000    0.0030
##      3        0.0326             nan     0.1000    0.0018
##      4        0.0290             nan     0.1000    0.0035
##      5        0.0262             nan     0.1000    0.0031
##      6        0.0248             nan     0.1000    0.0004
##      7        0.0223             nan     0.1000    0.0015
##      8        0.0207             nan     0.1000    0.0008
##      9        0.0187             nan     0.1000    0.0008
##     10        0.0171             nan     0.1000    0.0013
##     20        0.0086             nan     0.1000   -0.0002
##     40        0.0033             nan     0.1000    0.0002
##     60        0.0015             nan     0.1000   -0.0001
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.1000    0.0028
##      2        0.0323             nan     0.1000    0.0064
##      3        0.0276             nan     0.1000    0.0020
##      4        0.0235             nan     0.1000    0.0036
##      5        0.0204             nan     0.1000    0.0017
##      6        0.0175             nan     0.1000    0.0014
##      7        0.0158             nan     0.1000    0.0007
##      8        0.0149             nan     0.1000    0.0002
##      9        0.0137             nan     0.1000    0.0009
##     10        0.0126             nan     0.1000   -0.0003
##     20        0.0043             nan     0.1000    0.0003
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0062
##      2        0.0339             nan     0.1000    0.0053
##      3        0.0295             nan     0.1000    0.0034
##      4        0.0261             nan     0.1000    0.0034
##      5        0.0229             nan     0.1000    0.0030
##      6        0.0203             nan     0.1000    0.0033
##      7        0.0176             nan     0.1000    0.0005
##      8        0.0159             nan     0.1000    0.0017
##      9        0.0142             nan     0.1000    0.0013
##     10        0.0121             nan     0.1000    0.0019
##     20        0.0045             nan     0.1000   -0.0000
##     40        0.0010             nan     0.1000    0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0059
##      2        0.0345             nan     0.1000    0.0011
##      3        0.0305             nan     0.1000    0.0031
##      4        0.0286             nan     0.1000    0.0011
##      5        0.0257             nan     0.1000    0.0012
##      6        0.0228             nan     0.1000    0.0028
##      7        0.0216             nan     0.1000   -0.0004
##      8        0.0204             nan     0.1000    0.0011
##      9        0.0179             nan     0.1000    0.0016
##     10        0.0168             nan     0.1000    0.0007
##     20        0.0084             nan     0.1000    0.0001
##     40        0.0034             nan     0.1000    0.0001
##     60        0.0016             nan     0.1000    0.0001
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0054
##      2        0.0312             nan     0.1000    0.0031
##      3        0.0254             nan     0.1000    0.0029
##      4        0.0223             nan     0.1000    0.0020
##      5        0.0198             nan     0.1000    0.0012
##      6        0.0167             nan     0.1000    0.0017
##      7        0.0144             nan     0.1000    0.0014
##      8        0.0122             nan     0.1000    0.0005
##      9        0.0114             nan     0.1000    0.0006
##     10        0.0101             nan     0.1000    0.0007
##     20        0.0033             nan     0.1000    0.0001
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.1000    0.0020
##      2        0.0335             nan     0.1000    0.0047
##      3        0.0297             nan     0.1000    0.0034
##      4        0.0258             nan     0.1000    0.0024
##      5        0.0234             nan     0.1000    0.0020
##      6        0.0196             nan     0.1000    0.0024
##      7        0.0172             nan     0.1000    0.0008
##      8        0.0155             nan     0.1000    0.0017
##      9        0.0129             nan     0.1000    0.0010
##     10        0.0110             nan     0.1000    0.0016
##     20        0.0036             nan     0.1000    0.0002
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.1000    0.0033
##      2        0.0358             nan     0.1000    0.0044
##      3        0.0302             nan     0.1000    0.0047
##      4        0.0260             nan     0.1000    0.0033
##      5        0.0239             nan     0.1000    0.0017
##      6        0.0224             nan     0.1000    0.0009
##      7        0.0202             nan     0.1000    0.0013
##      8        0.0189             nan     0.1000    0.0010
##      9        0.0167             nan     0.1000    0.0011
##     10        0.0160             nan     0.1000   -0.0004
##     20        0.0075             nan     0.1000   -0.0007
##     40        0.0029             nan     0.1000    0.0001
##     60        0.0017             nan     0.1000   -0.0001
##     80        0.0008             nan     0.1000   -0.0001
##    100        0.0005             nan     0.1000    0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0001
##      2        0.0431             nan     0.0100    0.0001
##      3        0.0425             nan     0.0100    0.0005
##      4        0.0419             nan     0.0100    0.0004
##      5        0.0417             nan     0.0100    0.0002
##      6        0.0414             nan     0.0100    0.0002
##      7        0.0408             nan     0.0100    0.0006
##      8        0.0403             nan     0.0100    0.0006
##      9        0.0398             nan     0.0100    0.0003
##     10        0.0393             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0005
##     40        0.0276             nan     0.0100    0.0001
##     60        0.0226             nan     0.0100    0.0001
##     80        0.0185             nan     0.0100    0.0000
##    100        0.0149             nan     0.0100    0.0002
##    120        0.0122             nan     0.0100   -0.0000
##    140        0.0100             nan     0.0100    0.0001
##    160        0.0083             nan     0.0100    0.0001
##    180        0.0070             nan     0.0100    0.0000
##    200        0.0060             nan     0.0100   -0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0002
##      2        0.0430             nan     0.0100    0.0002
##      3        0.0425             nan     0.0100    0.0004
##      4        0.0419             nan     0.0100    0.0006
##      5        0.0414             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0006
##      7        0.0403             nan     0.0100    0.0005
##      8        0.0399             nan     0.0100    0.0002
##      9        0.0396             nan     0.0100   -0.0000
##     10        0.0391             nan     0.0100    0.0005
##     20        0.0342             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100    0.0001
##     60        0.0228             nan     0.0100   -0.0000
##     80        0.0184             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0125             nan     0.0100    0.0000
##    140        0.0106             nan     0.0100    0.0001
##    160        0.0089             nan     0.0100    0.0000
##    180        0.0076             nan     0.0100    0.0001
##    200        0.0066             nan     0.0100   -0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0005
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0421             nan     0.0100    0.0006
##      4        0.0417             nan     0.0100    0.0002
##      5        0.0412             nan     0.0100    0.0004
##      6        0.0408             nan     0.0100    0.0001
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0392             nan     0.0100    0.0001
##     10        0.0389             nan     0.0100    0.0002
##     20        0.0346             nan     0.0100    0.0003
##     40        0.0279             nan     0.0100    0.0000
##     60        0.0233             nan     0.0100    0.0001
##     80        0.0190             nan     0.0100    0.0002
##    100        0.0158             nan     0.0100    0.0000
##    120        0.0137             nan     0.0100    0.0001
##    140        0.0121             nan     0.0100   -0.0000
##    160        0.0105             nan     0.0100    0.0001
##    180        0.0090             nan     0.0100   -0.0000
##    200        0.0080             nan     0.0100   -0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0005
##      2        0.0423             nan     0.0100    0.0006
##      3        0.0418             nan     0.0100    0.0005
##      4        0.0412             nan     0.0100    0.0004
##      5        0.0405             nan     0.0100    0.0005
##      6        0.0400             nan     0.0100    0.0002
##      7        0.0394             nan     0.0100    0.0003
##      8        0.0388             nan     0.0100    0.0004
##      9        0.0384             nan     0.0100    0.0003
##     10        0.0379             nan     0.0100    0.0005
##     20        0.0333             nan     0.0100    0.0005
##     40        0.0257             nan     0.0100    0.0001
##     60        0.0193             nan     0.0100    0.0002
##     80        0.0153             nan     0.0100    0.0001
##    100        0.0120             nan     0.0100    0.0001
##    120        0.0094             nan     0.0100    0.0000
##    140        0.0077             nan     0.0100    0.0001
##    160        0.0060             nan     0.0100    0.0001
##    180        0.0048             nan     0.0100   -0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0002
##      2        0.0426             nan     0.0100    0.0004
##      3        0.0422             nan     0.0100    0.0002
##      4        0.0417             nan     0.0100    0.0003
##      5        0.0412             nan     0.0100    0.0002
##      6        0.0406             nan     0.0100    0.0002
##      7        0.0401             nan     0.0100    0.0001
##      8        0.0395             nan     0.0100    0.0007
##      9        0.0390             nan     0.0100    0.0004
##     10        0.0387             nan     0.0100    0.0001
##     20        0.0337             nan     0.0100    0.0005
##     40        0.0264             nan     0.0100    0.0002
##     60        0.0210             nan     0.0100    0.0003
##     80        0.0166             nan     0.0100    0.0002
##    100        0.0134             nan     0.0100    0.0001
##    120        0.0104             nan     0.0100    0.0001
##    140        0.0084             nan     0.0100    0.0001
##    160        0.0068             nan     0.0100    0.0001
##    180        0.0056             nan     0.0100    0.0000
##    200        0.0046             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0001
##      2        0.0426             nan     0.0100    0.0003
##      3        0.0420             nan     0.0100    0.0006
##      4        0.0417             nan     0.0100    0.0003
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0407             nan     0.0100    0.0006
##      7        0.0401             nan     0.0100    0.0006
##      8        0.0399             nan     0.0100   -0.0000
##      9        0.0393             nan     0.0100    0.0005
##     10        0.0386             nan     0.0100    0.0006
##     20        0.0341             nan     0.0100    0.0003
##     40        0.0268             nan     0.0100    0.0002
##     60        0.0218             nan     0.0100    0.0001
##     80        0.0181             nan     0.0100    0.0000
##    100        0.0149             nan     0.0100    0.0001
##    120        0.0129             nan     0.0100    0.0001
##    140        0.0111             nan     0.0100    0.0000
##    160        0.0097             nan     0.0100    0.0001
##    180        0.0087             nan     0.0100    0.0000
##    200        0.0078             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0008
##      2        0.0423             nan     0.0100    0.0005
##      3        0.0415             nan     0.0100    0.0005
##      4        0.0407             nan     0.0100    0.0007
##      5        0.0400             nan     0.0100    0.0005
##      6        0.0396             nan     0.0100    0.0005
##      7        0.0390             nan     0.0100    0.0003
##      8        0.0383             nan     0.0100    0.0006
##      9        0.0381             nan     0.0100   -0.0001
##     10        0.0379             nan     0.0100    0.0001
##     20        0.0326             nan     0.0100    0.0001
##     40        0.0243             nan     0.0100    0.0002
##     60        0.0181             nan     0.0100    0.0003
##     80        0.0143             nan     0.0100    0.0001
##    100        0.0111             nan     0.0100    0.0002
##    120        0.0086             nan     0.0100   -0.0000
##    140        0.0068             nan     0.0100    0.0000
##    160        0.0054             nan     0.0100   -0.0000
##    180        0.0044             nan     0.0100   -0.0000
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0003
##      2        0.0425             nan     0.0100    0.0008
##      3        0.0419             nan     0.0100    0.0006
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0405             nan     0.0100    0.0004
##      6        0.0400             nan     0.0100    0.0005
##      7        0.0397             nan     0.0100   -0.0003
##      8        0.0390             nan     0.0100    0.0001
##      9        0.0384             nan     0.0100    0.0005
##     10        0.0378             nan     0.0100    0.0006
##     20        0.0329             nan     0.0100    0.0005
##     40        0.0256             nan     0.0100    0.0003
##     60        0.0200             nan     0.0100    0.0002
##     80        0.0157             nan     0.0100    0.0000
##    100        0.0124             nan     0.0100    0.0000
##    120        0.0096             nan     0.0100    0.0001
##    140        0.0078             nan     0.0100    0.0001
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0423             nan     0.0100    0.0002
##      4        0.0418             nan     0.0100    0.0005
##      5        0.0414             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0404             nan     0.0100    0.0002
##      8        0.0402             nan     0.0100   -0.0002
##      9        0.0398             nan     0.0100    0.0003
##     10        0.0394             nan     0.0100    0.0002
##     20        0.0354             nan     0.0100    0.0003
##     40        0.0280             nan     0.0100    0.0002
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0182             nan     0.0100   -0.0001
##    100        0.0153             nan     0.0100    0.0001
##    120        0.0131             nan     0.0100    0.0001
##    140        0.0113             nan     0.0100    0.0001
##    160        0.0100             nan     0.0100    0.0000
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0015
##      2        0.0379             nan     0.0500    0.0029
##      3        0.0359             nan     0.0500    0.0017
##      4        0.0328             nan     0.0500    0.0021
##      5        0.0308             nan     0.0500    0.0015
##      6        0.0281             nan     0.0500    0.0018
##      7        0.0263             nan     0.0500    0.0016
##      8        0.0250             nan     0.0500    0.0007
##      9        0.0235             nan     0.0500    0.0009
##     10        0.0221             nan     0.0500    0.0012
##     20        0.0136             nan     0.0500    0.0002
##     40        0.0062             nan     0.0500    0.0003
##     60        0.0031             nan     0.0500    0.0001
##     80        0.0018             nan     0.0500    0.0000
##    100        0.0011             nan     0.0500   -0.0001
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0010
##      2        0.0392             nan     0.0500    0.0017
##      3        0.0372             nan     0.0500    0.0022
##      4        0.0352             nan     0.0500    0.0013
##      5        0.0328             nan     0.0500    0.0018
##      6        0.0310             nan     0.0500    0.0016
##      7        0.0298             nan     0.0500    0.0002
##      8        0.0281             nan     0.0500    0.0009
##      9        0.0263             nan     0.0500    0.0017
##     10        0.0244             nan     0.0500    0.0016
##     20        0.0145             nan     0.0500   -0.0001
##     40        0.0061             nan     0.0500    0.0002
##     60        0.0037             nan     0.0500   -0.0000
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0013             nan     0.0500   -0.0001
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0003             nan     0.0500   -0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0031
##      2        0.0389             nan     0.0500    0.0014
##      3        0.0379             nan     0.0500    0.0001
##      4        0.0363             nan     0.0500    0.0019
##      5        0.0341             nan     0.0500    0.0019
##      6        0.0320             nan     0.0500    0.0021
##      7        0.0304             nan     0.0500    0.0010
##      8        0.0285             nan     0.0500    0.0017
##      9        0.0268             nan     0.0500    0.0015
##     10        0.0252             nan     0.0500    0.0014
##     20        0.0167             nan     0.0500    0.0006
##     40        0.0089             nan     0.0500   -0.0001
##     60        0.0054             nan     0.0500   -0.0001
##     80        0.0032             nan     0.0500    0.0000
##    100        0.0023             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0017
##      2        0.0402             nan     0.0500   -0.0006
##      3        0.0380             nan     0.0500    0.0010
##      4        0.0351             nan     0.0500    0.0025
##      5        0.0327             nan     0.0500    0.0021
##      6        0.0313             nan     0.0500    0.0010
##      7        0.0292             nan     0.0500    0.0016
##      8        0.0274             nan     0.0500    0.0014
##      9        0.0253             nan     0.0500    0.0014
##     10        0.0235             nan     0.0500    0.0019
##     20        0.0126             nan     0.0500    0.0006
##     40        0.0037             nan     0.0500    0.0003
##     60        0.0013             nan     0.0500    0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0026
##      2        0.0379             nan     0.0500    0.0021
##      3        0.0351             nan     0.0500    0.0027
##      4        0.0318             nan     0.0500    0.0023
##      5        0.0300             nan     0.0500    0.0016
##      6        0.0280             nan     0.0500    0.0018
##      7        0.0260             nan     0.0500    0.0009
##      8        0.0247             nan     0.0500    0.0005
##      9        0.0232             nan     0.0500    0.0001
##     10        0.0211             nan     0.0500    0.0013
##     20        0.0122             nan     0.0500    0.0002
##     40        0.0045             nan     0.0500    0.0001
##     60        0.0023             nan     0.0500   -0.0000
##     80        0.0012             nan     0.0500   -0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0019
##      2        0.0384             nan     0.0500    0.0023
##      3        0.0354             nan     0.0500    0.0021
##      4        0.0332             nan     0.0500    0.0021
##      5        0.0318             nan     0.0500    0.0017
##      6        0.0295             nan     0.0500    0.0018
##      7        0.0281             nan     0.0500    0.0015
##      8        0.0263             nan     0.0500    0.0012
##      9        0.0253             nan     0.0500    0.0000
##     10        0.0237             nan     0.0500    0.0008
##     20        0.0143             nan     0.0500    0.0007
##     40        0.0085             nan     0.0500    0.0000
##     60        0.0051             nan     0.0500    0.0001
##     80        0.0033             nan     0.0500   -0.0000
##    100        0.0023             nan     0.0500   -0.0001
##    120        0.0017             nan     0.0500   -0.0001
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0031
##      2        0.0366             nan     0.0500    0.0028
##      3        0.0335             nan     0.0500    0.0026
##      4        0.0323             nan     0.0500   -0.0002
##      5        0.0296             nan     0.0500    0.0026
##      6        0.0279             nan     0.0500    0.0002
##      7        0.0259             nan     0.0500    0.0018
##      8        0.0247             nan     0.0500    0.0015
##      9        0.0231             nan     0.0500    0.0007
##     10        0.0220             nan     0.0500   -0.0001
##     20        0.0119             nan     0.0500    0.0004
##     40        0.0036             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500    0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0006
##      2        0.0388             nan     0.0500    0.0021
##      3        0.0360             nan     0.0500    0.0027
##      4        0.0342             nan     0.0500    0.0012
##      5        0.0324             nan     0.0500    0.0016
##      6        0.0298             nan     0.0500    0.0011
##      7        0.0278             nan     0.0500    0.0017
##      8        0.0266             nan     0.0500    0.0008
##      9        0.0255             nan     0.0500   -0.0002
##     10        0.0246             nan     0.0500    0.0004
##     20        0.0125             nan     0.0500    0.0002
##     40        0.0047             nan     0.0500   -0.0000
##     60        0.0023             nan     0.0500    0.0001
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0025
##      2        0.0380             nan     0.0500    0.0025
##      3        0.0365             nan     0.0500    0.0013
##      4        0.0345             nan     0.0500    0.0023
##      5        0.0324             nan     0.0500    0.0018
##      6        0.0305             nan     0.0500    0.0012
##      7        0.0283             nan     0.0500    0.0017
##      8        0.0264             nan     0.0500    0.0012
##      9        0.0253             nan     0.0500    0.0014
##     10        0.0245             nan     0.0500    0.0004
##     20        0.0158             nan     0.0500    0.0001
##     40        0.0074             nan     0.0500    0.0002
##     60        0.0046             nan     0.0500    0.0000
##     80        0.0031             nan     0.0500    0.0001
##    100        0.0020             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0007             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0052
##      2        0.0323             nan     0.1000    0.0045
##      3        0.0303             nan     0.1000    0.0014
##      4        0.0265             nan     0.1000    0.0013
##      5        0.0245             nan     0.1000    0.0016
##      6        0.0222             nan     0.1000    0.0018
##      7        0.0202             nan     0.1000    0.0016
##      8        0.0181             nan     0.1000    0.0019
##      9        0.0176             nan     0.1000    0.0001
##     10        0.0155             nan     0.1000    0.0009
##     20        0.0067             nan     0.1000    0.0000
##     40        0.0016             nan     0.1000   -0.0000
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0059
##      2        0.0342             nan     0.1000    0.0011
##      3        0.0316             nan     0.1000    0.0003
##      4        0.0281             nan     0.1000    0.0023
##      5        0.0253             nan     0.1000    0.0032
##      6        0.0231             nan     0.1000    0.0017
##      7        0.0206             nan     0.1000    0.0016
##      8        0.0201             nan     0.1000   -0.0006
##      9        0.0186             nan     0.1000    0.0007
##     10        0.0179             nan     0.1000    0.0003
##     20        0.0079             nan     0.1000    0.0005
##     40        0.0025             nan     0.1000   -0.0001
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0036
##      2        0.0353             nan     0.1000    0.0008
##      3        0.0321             nan     0.1000    0.0025
##      4        0.0283             nan     0.1000    0.0024
##      5        0.0249             nan     0.1000    0.0032
##      6        0.0226             nan     0.1000    0.0025
##      7        0.0205             nan     0.1000    0.0022
##      8        0.0185             nan     0.1000    0.0015
##      9        0.0174             nan     0.1000    0.0009
##     10        0.0175             nan     0.1000   -0.0018
##     20        0.0087             nan     0.1000    0.0004
##     40        0.0031             nan     0.1000   -0.0002
##     60        0.0015             nan     0.1000    0.0000
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.1000   -0.0002
##      2        0.0344             nan     0.1000    0.0019
##      3        0.0293             nan     0.1000    0.0032
##      4        0.0248             nan     0.1000    0.0033
##      5        0.0228             nan     0.1000    0.0001
##      6        0.0210             nan     0.1000    0.0017
##      7        0.0188             nan     0.1000    0.0027
##      8        0.0171             nan     0.1000    0.0013
##      9        0.0165             nan     0.1000   -0.0017
##     10        0.0142             nan     0.1000    0.0005
##     20        0.0042             nan     0.1000    0.0001
##     40        0.0005             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0073
##      2        0.0313             nan     0.1000    0.0055
##      3        0.0270             nan     0.1000    0.0038
##      4        0.0224             nan     0.1000    0.0024
##      5        0.0209             nan     0.1000   -0.0000
##      6        0.0176             nan     0.1000    0.0030
##      7        0.0149             nan     0.1000    0.0015
##      8        0.0131             nan     0.1000    0.0007
##      9        0.0122             nan     0.1000    0.0005
##     10        0.0110             nan     0.1000    0.0007
##     20        0.0034             nan     0.1000    0.0004
##     40        0.0008             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.1000    0.0058
##      2        0.0322             nan     0.1000    0.0049
##      3        0.0315             nan     0.1000   -0.0020
##      4        0.0280             nan     0.1000    0.0035
##      5        0.0256             nan     0.1000    0.0006
##      6        0.0240             nan     0.1000    0.0006
##      7        0.0217             nan     0.1000    0.0023
##      8        0.0204             nan     0.1000    0.0009
##      9        0.0200             nan     0.1000   -0.0000
##     10        0.0184             nan     0.1000    0.0018
##     20        0.0101             nan     0.1000    0.0003
##     40        0.0040             nan     0.1000    0.0001
##     60        0.0021             nan     0.1000   -0.0002
##     80        0.0013             nan     0.1000   -0.0001
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0041
##      2        0.0327             nan     0.1000    0.0045
##      3        0.0257             nan     0.1000    0.0061
##      4        0.0214             nan     0.1000    0.0028
##      5        0.0180             nan     0.1000    0.0025
##      6        0.0151             nan     0.1000    0.0016
##      7        0.0130             nan     0.1000    0.0014
##      8        0.0113             nan     0.1000    0.0012
##      9        0.0104             nan     0.1000    0.0005
##     10        0.0094             nan     0.1000    0.0003
##     20        0.0032             nan     0.1000    0.0002
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.1000    0.0029
##      2        0.0330             nan     0.1000    0.0040
##      3        0.0288             nan     0.1000    0.0027
##      4        0.0257             nan     0.1000    0.0039
##      5        0.0216             nan     0.1000    0.0032
##      6        0.0189             nan     0.1000    0.0023
##      7        0.0159             nan     0.1000    0.0016
##      8        0.0145             nan     0.1000    0.0009
##      9        0.0136             nan     0.1000    0.0009
##     10        0.0126             nan     0.1000    0.0007
##     20        0.0056             nan     0.1000    0.0002
##     40        0.0010             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0057
##      2        0.0360             nan     0.1000    0.0018
##      3        0.0337             nan     0.1000   -0.0003
##      4        0.0312             nan     0.1000    0.0010
##      5        0.0275             nan     0.1000    0.0022
##      6        0.0243             nan     0.1000    0.0029
##      7        0.0233             nan     0.1000   -0.0004
##      8        0.0212             nan     0.1000    0.0017
##      9        0.0188             nan     0.1000    0.0023
##     10        0.0179             nan     0.1000   -0.0001
##     20        0.0096             nan     0.1000    0.0007
##     40        0.0038             nan     0.1000    0.0001
##     60        0.0018             nan     0.1000   -0.0001
##     80        0.0012             nan     0.1000    0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.0100    0.0005
##      2        0.0363             nan     0.0100    0.0002
##      3        0.0358             nan     0.0100    0.0005
##      4        0.0353             nan     0.0100    0.0005
##      5        0.0349             nan     0.0100    0.0002
##      6        0.0344             nan     0.0100    0.0005
##      7        0.0341             nan     0.0100    0.0001
##      8        0.0336             nan     0.0100    0.0002
##      9        0.0334             nan     0.0100    0.0002
##     10        0.0329             nan     0.0100    0.0005
##     20        0.0288             nan     0.0100    0.0002
##     40        0.0233             nan     0.0100    0.0002
##     60        0.0190             nan     0.0100    0.0001
##     80        0.0159             nan     0.0100    0.0002
##    100        0.0129             nan     0.0100    0.0000
##    120        0.0110             nan     0.0100   -0.0000
##    140        0.0093             nan     0.0100    0.0000
##    160        0.0079             nan     0.0100    0.0001
##    180        0.0068             nan     0.0100    0.0001
##    200        0.0056             nan     0.0100    0.0001
## 
## - Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.0100    0.0005
##      2        0.0365             nan     0.0100    0.0001
##      3        0.0362             nan     0.0100    0.0004
##      4        0.0357             nan     0.0100    0.0005
##      5        0.0351             nan     0.0100    0.0006
##      6        0.0346             nan     0.0100    0.0005
##      7        0.0341             nan     0.0100    0.0003
##      8        0.0337             nan     0.0100    0.0005
##      9        0.0332             nan     0.0100    0.0003
##     10        0.0329             nan     0.0100   -0.0001
##     20        0.0293             nan     0.0100    0.0004
##     40        0.0237             nan     0.0100    0.0003
##     60        0.0190             nan     0.0100    0.0001
##     80        0.0157             nan     0.0100    0.0000
##    100        0.0131             nan     0.0100    0.0001
##    120        0.0109             nan     0.0100    0.0000
##    140        0.0092             nan     0.0100   -0.0000
##    160        0.0079             nan     0.0100    0.0001
##    180        0.0069             nan     0.0100    0.0000
##    200        0.0059             nan     0.0100    0.0001
## 
## - Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.0100    0.0004
##      2        0.0364             nan     0.0100    0.0005
##      3        0.0361             nan     0.0100    0.0004
##      4        0.0355             nan     0.0100    0.0005
##      5        0.0352             nan     0.0100    0.0003
##      6        0.0347             nan     0.0100    0.0001
##      7        0.0343             nan     0.0100    0.0005
##      8        0.0338             nan     0.0100    0.0005
##      9        0.0334             nan     0.0100    0.0004
##     10        0.0331             nan     0.0100    0.0001
##     20        0.0296             nan     0.0100    0.0004
##     40        0.0239             nan     0.0100    0.0002
##     60        0.0200             nan     0.0100    0.0002
##     80        0.0166             nan     0.0100   -0.0001
##    100        0.0141             nan     0.0100    0.0001
##    120        0.0122             nan     0.0100    0.0001
##    140        0.0108             nan     0.0100   -0.0000
##    160        0.0096             nan     0.0100   -0.0000
##    180        0.0084             nan     0.0100   -0.0000
##    200        0.0076             nan     0.0100   -0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.0100    0.0004
##      2        0.0364             nan     0.0100    0.0005
##      3        0.0358             nan     0.0100    0.0004
##      4        0.0352             nan     0.0100    0.0003
##      5        0.0346             nan     0.0100    0.0005
##      6        0.0342             nan     0.0100    0.0003
##      7        0.0336             nan     0.0100    0.0004
##      8        0.0330             nan     0.0100    0.0005
##      9        0.0325             nan     0.0100    0.0006
##     10        0.0319             nan     0.0100    0.0003
##     20        0.0276             nan     0.0100    0.0004
##     40        0.0212             nan     0.0100    0.0002
##     60        0.0164             nan     0.0100    0.0000
##     80        0.0127             nan     0.0100   -0.0000
##    100        0.0099             nan     0.0100    0.0001
##    120        0.0078             nan     0.0100    0.0000
##    140        0.0063             nan     0.0100    0.0000
##    160        0.0050             nan     0.0100   -0.0000
##    180        0.0042             nan     0.0100    0.0000
##    200        0.0035             nan     0.0100    0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.0100    0.0005
##      2        0.0364             nan     0.0100    0.0005
##      3        0.0358             nan     0.0100    0.0003
##      4        0.0355             nan     0.0100    0.0002
##      5        0.0351             nan     0.0100    0.0002
##      6        0.0345             nan     0.0100    0.0004
##      7        0.0339             nan     0.0100    0.0006
##      8        0.0335             nan     0.0100    0.0002
##      9        0.0331             nan     0.0100   -0.0001
##     10        0.0328             nan     0.0100    0.0003
##     20        0.0282             nan     0.0100    0.0003
##     40        0.0219             nan     0.0100    0.0000
##     60        0.0168             nan     0.0100    0.0002
##     80        0.0134             nan     0.0100    0.0000
##    100        0.0107             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0071             nan     0.0100    0.0000
##    160        0.0060             nan     0.0100    0.0001
##    180        0.0051             nan     0.0100    0.0000
##    200        0.0042             nan     0.0100    0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.0100    0.0003
##      2        0.0367             nan     0.0100    0.0002
##      3        0.0362             nan     0.0100    0.0005
##      4        0.0357             nan     0.0100    0.0005
##      5        0.0352             nan     0.0100    0.0005
##      6        0.0348             nan     0.0100    0.0001
##      7        0.0345             nan     0.0100    0.0003
##      8        0.0342             nan     0.0100    0.0003
##      9        0.0338             nan     0.0100    0.0004
##     10        0.0334             nan     0.0100    0.0004
##     20        0.0294             nan     0.0100    0.0002
##     40        0.0232             nan     0.0100    0.0001
##     60        0.0189             nan     0.0100    0.0001
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0131             nan     0.0100    0.0001
##    120        0.0113             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0000
##    160        0.0090             nan     0.0100    0.0001
##    180        0.0080             nan     0.0100    0.0000
##    200        0.0073             nan     0.0100   -0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.0100    0.0005
##      2        0.0363             nan     0.0100    0.0004
##      3        0.0356             nan     0.0100    0.0004
##      4        0.0351             nan     0.0100    0.0002
##      5        0.0346             nan     0.0100    0.0004
##      6        0.0341             nan     0.0100    0.0004
##      7        0.0336             nan     0.0100    0.0005
##      8        0.0329             nan     0.0100    0.0005
##      9        0.0323             nan     0.0100    0.0003
##     10        0.0318             nan     0.0100    0.0005
##     20        0.0270             nan     0.0100    0.0003
##     40        0.0202             nan     0.0100    0.0002
##     60        0.0154             nan     0.0100    0.0001
##     80        0.0119             nan     0.0100    0.0001
##    100        0.0092             nan     0.0100    0.0000
##    120        0.0071             nan     0.0100    0.0001
##    140        0.0057             nan     0.0100    0.0000
##    160        0.0044             nan     0.0100    0.0000
##    180        0.0035             nan     0.0100   -0.0000
##    200        0.0028             nan     0.0100    0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.0100    0.0001
##      2        0.0366             nan     0.0100    0.0002
##      3        0.0361             nan     0.0100    0.0002
##      4        0.0355             nan     0.0100    0.0005
##      5        0.0349             nan     0.0100    0.0003
##      6        0.0343             nan     0.0100    0.0003
##      7        0.0339             nan     0.0100    0.0004
##      8        0.0333             nan     0.0100    0.0003
##      9        0.0330             nan     0.0100    0.0002
##     10        0.0325             nan     0.0100    0.0004
##     20        0.0286             nan     0.0100    0.0003
##     40        0.0217             nan     0.0100    0.0002
##     60        0.0172             nan     0.0100    0.0002
##     80        0.0135             nan     0.0100    0.0000
##    100        0.0108             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0069             nan     0.0100    0.0001
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.0100    0.0001
##      2        0.0368             nan     0.0100   -0.0000
##      3        0.0364             nan     0.0100    0.0005
##      4        0.0361             nan     0.0100    0.0003
##      5        0.0357             nan     0.0100    0.0004
##      6        0.0352             nan     0.0100    0.0005
##      7        0.0348             nan     0.0100    0.0002
##      8        0.0345             nan     0.0100    0.0001
##      9        0.0342             nan     0.0100    0.0001
##     10        0.0339             nan     0.0100    0.0004
##     20        0.0304             nan     0.0100    0.0004
##     40        0.0244             nan     0.0100    0.0002
##     60        0.0198             nan     0.0100    0.0002
##     80        0.0168             nan     0.0100    0.0001
##    100        0.0142             nan     0.0100    0.0000
##    120        0.0122             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0001
##    160        0.0092             nan     0.0100    0.0000
##    180        0.0083             nan     0.0100    0.0000
##    200        0.0074             nan     0.0100   -0.0000
## 
## - Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0354             nan     0.0500    0.0018
##      2        0.0332             nan     0.0500    0.0014
##      3        0.0314             nan     0.0500    0.0010
##      4        0.0294             nan     0.0500    0.0015
##      5        0.0272             nan     0.0500    0.0016
##      6        0.0251             nan     0.0500    0.0015
##      7        0.0236             nan     0.0500    0.0009
##      8        0.0227             nan     0.0500    0.0008
##      9        0.0216             nan     0.0500    0.0006
##     10        0.0202             nan     0.0500    0.0014
##     20        0.0128             nan     0.0500   -0.0001
##     40        0.0053             nan     0.0500    0.0001
##     60        0.0026             nan     0.0500    0.0001
##     80        0.0015             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0353             nan     0.0500    0.0016
##      2        0.0336             nan     0.0500    0.0016
##      3        0.0324             nan     0.0500    0.0004
##      4        0.0302             nan     0.0500    0.0017
##      5        0.0278             nan     0.0500    0.0018
##      6        0.0259             nan     0.0500    0.0016
##      7        0.0244             nan     0.0500    0.0015
##      8        0.0230             nan     0.0500    0.0010
##      9        0.0216             nan     0.0500    0.0014
##     10        0.0211             nan     0.0500   -0.0007
##     20        0.0135             nan     0.0500   -0.0002
##     40        0.0062             nan     0.0500    0.0001
##     60        0.0028             nan     0.0500    0.0000
##     80        0.0016             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0355             nan     0.0500    0.0004
##      2        0.0327             nan     0.0500    0.0025
##      3        0.0305             nan     0.0500    0.0017
##      4        0.0283             nan     0.0500    0.0015
##      5        0.0273             nan     0.0500    0.0007
##      6        0.0255             nan     0.0500    0.0014
##      7        0.0243             nan     0.0500    0.0012
##      8        0.0228             nan     0.0500    0.0010
##      9        0.0213             nan     0.0500    0.0013
##     10        0.0202             nan     0.0500    0.0010
##     20        0.0128             nan     0.0500    0.0005
##     40        0.0072             nan     0.0500   -0.0002
##     60        0.0049             nan     0.0500   -0.0000
##     80        0.0033             nan     0.0500   -0.0001
##    100        0.0025             nan     0.0500   -0.0000
##    120        0.0018             nan     0.0500   -0.0000
##    140        0.0014             nan     0.0500   -0.0000
##    160        0.0011             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500    0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0348             nan     0.0500    0.0021
##      2        0.0322             nan     0.0500    0.0016
##      3        0.0299             nan     0.0500    0.0022
##      4        0.0280             nan     0.0500    0.0008
##      5        0.0268             nan     0.0500    0.0003
##      6        0.0250             nan     0.0500    0.0016
##      7        0.0230             nan     0.0500    0.0018
##      8        0.0209             nan     0.0500    0.0017
##      9        0.0190             nan     0.0500    0.0012
##     10        0.0182             nan     0.0500    0.0009
##     20        0.0103             nan     0.0500    0.0004
##     40        0.0032             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500    0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0339             nan     0.0500    0.0026
##      2        0.0314             nan     0.0500    0.0004
##      3        0.0290             nan     0.0500    0.0006
##      4        0.0265             nan     0.0500    0.0022
##      5        0.0249             nan     0.0500    0.0018
##      6        0.0232             nan     0.0500    0.0013
##      7        0.0224             nan     0.0500    0.0007
##      8        0.0216             nan     0.0500    0.0005
##      9        0.0201             nan     0.0500    0.0014
##     10        0.0188             nan     0.0500    0.0010
##     20        0.0111             nan     0.0500    0.0000
##     40        0.0042             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500    0.0000
##     80        0.0010             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0350             nan     0.0500    0.0024
##      2        0.0331             nan     0.0500    0.0021
##      3        0.0308             nan     0.0500    0.0023
##      4        0.0296             nan     0.0500   -0.0009
##      5        0.0281             nan     0.0500    0.0017
##      6        0.0266             nan     0.0500    0.0010
##      7        0.0253             nan     0.0500    0.0007
##      8        0.0234             nan     0.0500    0.0017
##      9        0.0223             nan     0.0500    0.0011
##     10        0.0215             nan     0.0500    0.0008
##     20        0.0137             nan     0.0500    0.0003
##     40        0.0071             nan     0.0500    0.0002
##     60        0.0044             nan     0.0500    0.0001
##     80        0.0030             nan     0.0500   -0.0001
##    100        0.0023             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500    0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0346             nan     0.0500    0.0019
##      2        0.0319             nan     0.0500    0.0027
##      3        0.0300             nan     0.0500    0.0019
##      4        0.0272             nan     0.0500    0.0019
##      5        0.0249             nan     0.0500    0.0021
##      6        0.0237             nan     0.0500    0.0010
##      7        0.0225             nan     0.0500    0.0014
##      8        0.0203             nan     0.0500    0.0022
##      9        0.0189             nan     0.0500    0.0013
##     10        0.0177             nan     0.0500    0.0003
##     20        0.0092             nan     0.0500    0.0007
##     40        0.0028             nan     0.0500    0.0000
##     60        0.0009             nan     0.0500   -0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0347             nan     0.0500    0.0030
##      2        0.0319             nan     0.0500    0.0024
##      3        0.0291             nan     0.0500    0.0025
##      4        0.0267             nan     0.0500    0.0022
##      5        0.0242             nan     0.0500    0.0016
##      6        0.0228             nan     0.0500    0.0011
##      7        0.0211             nan     0.0500    0.0013
##      8        0.0197             nan     0.0500    0.0011
##      9        0.0187             nan     0.0500    0.0003
##     10        0.0170             nan     0.0500    0.0013
##     20        0.0094             nan     0.0500    0.0005
##     40        0.0032             nan     0.0500    0.0001
##     60        0.0014             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0347             nan     0.0500    0.0026
##      2        0.0334             nan     0.0500    0.0008
##      3        0.0312             nan     0.0500    0.0022
##      4        0.0292             nan     0.0500    0.0018
##      5        0.0275             nan     0.0500    0.0017
##      6        0.0262             nan     0.0500    0.0011
##      7        0.0251             nan     0.0500    0.0002
##      8        0.0241             nan     0.0500    0.0007
##      9        0.0228             nan     0.0500    0.0011
##     10        0.0215             nan     0.0500    0.0013
##     20        0.0133             nan     0.0500    0.0003
##     40        0.0070             nan     0.0500    0.0002
##     60        0.0046             nan     0.0500   -0.0000
##     80        0.0034             nan     0.0500   -0.0001
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0018             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500    0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0338             nan     0.1000    0.0024
##      2        0.0290             nan     0.1000    0.0049
##      3        0.0268             nan     0.1000    0.0010
##      4        0.0252             nan     0.1000    0.0001
##      5        0.0225             nan     0.1000    0.0026
##      6        0.0219             nan     0.1000   -0.0018
##      7        0.0195             nan     0.1000    0.0026
##      8        0.0178             nan     0.1000    0.0013
##      9        0.0154             nan     0.1000    0.0016
##     10        0.0147             nan     0.1000   -0.0005
##     20        0.0068             nan     0.1000    0.0004
##     40        0.0016             nan     0.1000    0.0002
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0329             nan     0.1000    0.0036
##      2        0.0291             nan     0.1000    0.0039
##      3        0.0266             nan     0.1000    0.0026
##      4        0.0257             nan     0.1000   -0.0000
##      5        0.0224             nan     0.1000    0.0023
##      6        0.0211             nan     0.1000    0.0013
##      7        0.0182             nan     0.1000    0.0012
##      8        0.0172             nan     0.1000   -0.0002
##      9        0.0153             nan     0.1000    0.0005
##     10        0.0132             nan     0.1000    0.0013
##     20        0.0062             nan     0.1000    0.0004
##     40        0.0022             nan     0.1000   -0.0000
##     60        0.0011             nan     0.1000   -0.0000
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0329             nan     0.1000    0.0046
##      2        0.0296             nan     0.1000    0.0021
##      3        0.0264             nan     0.1000    0.0010
##      4        0.0241             nan     0.1000    0.0015
##      5        0.0224             nan     0.1000    0.0014
##      6        0.0204             nan     0.1000    0.0016
##      7        0.0194             nan     0.1000    0.0004
##      8        0.0183             nan     0.1000    0.0008
##      9        0.0175             nan     0.1000   -0.0006
##     10        0.0160             nan     0.1000    0.0010
##     20        0.0088             nan     0.1000   -0.0001
##     40        0.0038             nan     0.1000   -0.0001
##     60        0.0019             nan     0.1000    0.0000
##     80        0.0011             nan     0.1000   -0.0001
##    100        0.0006             nan     0.1000    0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0332             nan     0.1000    0.0015
##      2        0.0301             nan     0.1000    0.0000
##      3        0.0262             nan     0.1000    0.0044
##      4        0.0233             nan     0.1000    0.0030
##      5        0.0201             nan     0.1000    0.0026
##      6        0.0184             nan     0.1000   -0.0004
##      7        0.0175             nan     0.1000    0.0002
##      8        0.0159             nan     0.1000    0.0002
##      9        0.0134             nan     0.1000    0.0020
##     10        0.0123             nan     0.1000    0.0007
##     20        0.0038             nan     0.1000    0.0001
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0311             nan     0.1000    0.0038
##      2        0.0282             nan     0.1000    0.0028
##      3        0.0246             nan     0.1000    0.0019
##      4        0.0222             nan     0.1000    0.0022
##      5        0.0203             nan     0.1000    0.0014
##      6        0.0172             nan     0.1000    0.0023
##      7        0.0147             nan     0.1000    0.0012
##      8        0.0127             nan     0.1000    0.0010
##      9        0.0106             nan     0.1000    0.0013
##     10        0.0095             nan     0.1000    0.0002
##     20        0.0042             nan     0.1000   -0.0000
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0332             nan     0.1000    0.0037
##      2        0.0290             nan     0.1000    0.0040
##      3        0.0250             nan     0.1000    0.0037
##      4        0.0224             nan     0.1000    0.0028
##      5        0.0217             nan     0.1000   -0.0007
##      6        0.0202             nan     0.1000    0.0012
##      7        0.0195             nan     0.1000   -0.0013
##      8        0.0167             nan     0.1000    0.0014
##      9        0.0155             nan     0.1000    0.0008
##     10        0.0147             nan     0.1000    0.0009
##     20        0.0081             nan     0.1000    0.0002
##     40        0.0034             nan     0.1000    0.0000
##     60        0.0018             nan     0.1000   -0.0001
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0314             nan     0.1000    0.0054
##      2        0.0273             nan     0.1000    0.0012
##      3        0.0221             nan     0.1000    0.0047
##      4        0.0197             nan     0.1000    0.0005
##      5        0.0163             nan     0.1000    0.0027
##      6        0.0143             nan     0.1000    0.0010
##      7        0.0125             nan     0.1000    0.0011
##      8        0.0111             nan     0.1000    0.0011
##      9        0.0098             nan     0.1000   -0.0000
##     10        0.0089             nan     0.1000    0.0003
##     20        0.0025             nan     0.1000    0.0001
##     40        0.0003             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0336             nan     0.1000    0.0013
##      2        0.0301             nan     0.1000    0.0040
##      3        0.0264             nan     0.1000    0.0041
##      4        0.0241             nan     0.1000    0.0017
##      5        0.0211             nan     0.1000    0.0019
##      6        0.0190             nan     0.1000    0.0008
##      7        0.0174             nan     0.1000    0.0001
##      8        0.0156             nan     0.1000   -0.0000
##      9        0.0139             nan     0.1000    0.0022
##     10        0.0126             nan     0.1000    0.0015
##     20        0.0050             nan     0.1000   -0.0001
##     40        0.0013             nan     0.1000    0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0334             nan     0.1000    0.0040
##      2        0.0297             nan     0.1000    0.0035
##      3        0.0266             nan     0.1000    0.0014
##      4        0.0245             nan     0.1000    0.0023
##      5        0.0215             nan     0.1000    0.0011
##      6        0.0190             nan     0.1000    0.0019
##      7        0.0167             nan     0.1000    0.0021
##      8        0.0157             nan     0.1000    0.0003
##      9        0.0140             nan     0.1000    0.0008
##     10        0.0127             nan     0.1000    0.0008
##     20        0.0067             nan     0.1000    0.0003
##     40        0.0030             nan     0.1000    0.0001
##     60        0.0020             nan     0.1000   -0.0001
##     80        0.0012             nan     0.1000   -0.0000
##    100        0.0007             nan     0.1000    0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0005
##      2        0.0432             nan     0.0100    0.0006
##      3        0.0429             nan     0.0100    0.0002
##      4        0.0421             nan     0.0100    0.0006
##      5        0.0417             nan     0.0100    0.0001
##      6        0.0416             nan     0.0100   -0.0002
##      7        0.0413             nan     0.0100    0.0001
##      8        0.0408             nan     0.0100    0.0005
##      9        0.0401             nan     0.0100    0.0006
##     10        0.0396             nan     0.0100    0.0004
##     20        0.0348             nan     0.0100    0.0004
##     40        0.0276             nan     0.0100    0.0002
##     60        0.0221             nan     0.0100   -0.0000
##     80        0.0180             nan     0.0100    0.0001
##    100        0.0146             nan     0.0100    0.0001
##    120        0.0123             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0001
##    160        0.0087             nan     0.0100    0.0000
##    180        0.0074             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0002
##      2        0.0433             nan     0.0100    0.0006
##      3        0.0426             nan     0.0100    0.0005
##      4        0.0420             nan     0.0100    0.0005
##      5        0.0415             nan     0.0100    0.0003
##      6        0.0409             nan     0.0100    0.0005
##      7        0.0403             nan     0.0100    0.0002
##      8        0.0397             nan     0.0100    0.0002
##      9        0.0395             nan     0.0100   -0.0001
##     10        0.0391             nan     0.0100    0.0001
##     20        0.0346             nan     0.0100    0.0005
##     40        0.0279             nan     0.0100    0.0004
##     60        0.0224             nan     0.0100    0.0000
##     80        0.0184             nan     0.0100    0.0002
##    100        0.0150             nan     0.0100    0.0002
##    120        0.0124             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0000
##    160        0.0088             nan     0.0100    0.0000
##    180        0.0074             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0003
##      2        0.0434             nan     0.0100    0.0005
##      3        0.0430             nan     0.0100    0.0002
##      4        0.0426             nan     0.0100    0.0003
##      5        0.0421             nan     0.0100    0.0002
##      6        0.0415             nan     0.0100    0.0005
##      7        0.0409             nan     0.0100    0.0006
##      8        0.0405             nan     0.0100    0.0004
##      9        0.0399             nan     0.0100    0.0006
##     10        0.0396             nan     0.0100    0.0002
##     20        0.0355             nan     0.0100    0.0004
##     40        0.0285             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0002
##    100        0.0156             nan     0.0100    0.0001
##    120        0.0131             nan     0.0100    0.0001
##    140        0.0115             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100    0.0000
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100   -0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0441             nan     0.0100    0.0002
##      2        0.0432             nan     0.0100    0.0005
##      3        0.0426             nan     0.0100    0.0006
##      4        0.0422             nan     0.0100    0.0002
##      5        0.0416             nan     0.0100    0.0005
##      6        0.0408             nan     0.0100    0.0008
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0390             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0004
##     20        0.0335             nan     0.0100    0.0003
##     40        0.0252             nan     0.0100    0.0004
##     60        0.0188             nan     0.0100    0.0002
##     80        0.0142             nan     0.0100    0.0001
##    100        0.0112             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0000
##    160        0.0056             nan     0.0100    0.0000
##    180        0.0044             nan     0.0100    0.0000
##    200        0.0035             nan     0.0100   -0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0005
##      2        0.0432             nan     0.0100    0.0006
##      3        0.0425             nan     0.0100    0.0005
##      4        0.0422             nan     0.0100    0.0003
##      5        0.0415             nan     0.0100    0.0007
##      6        0.0407             nan     0.0100    0.0005
##      7        0.0402             nan     0.0100    0.0004
##      8        0.0399             nan     0.0100   -0.0001
##      9        0.0393             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0003
##     20        0.0338             nan     0.0100    0.0002
##     40        0.0259             nan     0.0100    0.0002
##     60        0.0199             nan     0.0100    0.0001
##     80        0.0160             nan     0.0100    0.0002
##    100        0.0128             nan     0.0100    0.0002
##    120        0.0101             nan     0.0100    0.0000
##    140        0.0082             nan     0.0100    0.0001
##    160        0.0066             nan     0.0100   -0.0000
##    180        0.0054             nan     0.0100    0.0000
##    200        0.0045             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0005
##      2        0.0431             nan     0.0100    0.0006
##      3        0.0426             nan     0.0100    0.0003
##      4        0.0421             nan     0.0100    0.0004
##      5        0.0415             nan     0.0100    0.0005
##      6        0.0412             nan     0.0100    0.0002
##      7        0.0408             nan     0.0100    0.0003
##      8        0.0403             nan     0.0100    0.0005
##      9        0.0400             nan     0.0100    0.0002
##     10        0.0396             nan     0.0100    0.0003
##     20        0.0355             nan     0.0100    0.0004
##     40        0.0283             nan     0.0100    0.0002
##     60        0.0231             nan     0.0100    0.0003
##     80        0.0193             nan     0.0100    0.0002
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0142             nan     0.0100    0.0000
##    140        0.0122             nan     0.0100   -0.0000
##    160        0.0104             nan     0.0100    0.0000
##    180        0.0091             nan     0.0100    0.0000
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0006
##      2        0.0431             nan     0.0100    0.0003
##      3        0.0423             nan     0.0100    0.0005
##      4        0.0416             nan     0.0100    0.0009
##      5        0.0409             nan     0.0100    0.0004
##      6        0.0405             nan     0.0100   -0.0001
##      7        0.0399             nan     0.0100    0.0003
##      8        0.0393             nan     0.0100    0.0004
##      9        0.0387             nan     0.0100    0.0005
##     10        0.0381             nan     0.0100    0.0005
##     20        0.0329             nan     0.0100    0.0004
##     40        0.0249             nan     0.0100    0.0002
##     60        0.0188             nan     0.0100   -0.0000
##     80        0.0143             nan     0.0100    0.0002
##    100        0.0109             nan     0.0100    0.0001
##    120        0.0085             nan     0.0100    0.0000
##    140        0.0069             nan     0.0100    0.0000
##    160        0.0054             nan     0.0100   -0.0000
##    180        0.0042             nan     0.0100    0.0000
##    200        0.0034             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0433             nan     0.0100    0.0005
##      3        0.0427             nan     0.0100    0.0005
##      4        0.0419             nan     0.0100    0.0005
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0405             nan     0.0100    0.0006
##      7        0.0399             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100    0.0003
##      9        0.0389             nan     0.0100    0.0002
##     10        0.0383             nan     0.0100    0.0006
##     20        0.0333             nan     0.0100    0.0005
##     40        0.0259             nan     0.0100    0.0002
##     60        0.0201             nan     0.0100    0.0002
##     80        0.0155             nan     0.0100    0.0001
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0096             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100   -0.0000
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0006
##      2        0.0431             nan     0.0100    0.0005
##      3        0.0425             nan     0.0100    0.0002
##      4        0.0419             nan     0.0100    0.0005
##      5        0.0416             nan     0.0100    0.0002
##      6        0.0412             nan     0.0100    0.0005
##      7        0.0408             nan     0.0100    0.0003
##      8        0.0402             nan     0.0100    0.0005
##      9        0.0398             nan     0.0100    0.0003
##     10        0.0393             nan     0.0100    0.0002
##     20        0.0350             nan     0.0100    0.0004
##     40        0.0282             nan     0.0100    0.0001
##     60        0.0222             nan     0.0100    0.0001
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100    0.0001
##    140        0.0114             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100    0.0000
##    180        0.0089             nan     0.0100   -0.0000
##    200        0.0078             nan     0.0100    0.0001
## 
## - Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0034
##      2        0.0384             nan     0.0500    0.0019
##      3        0.0359             nan     0.0500    0.0023
##      4        0.0337             nan     0.0500    0.0020
##      5        0.0314             nan     0.0500    0.0015
##      6        0.0289             nan     0.0500    0.0015
##      7        0.0270             nan     0.0500    0.0007
##      8        0.0255             nan     0.0500    0.0010
##      9        0.0246             nan     0.0500    0.0001
##     10        0.0231             nan     0.0500    0.0013
##     20        0.0138             nan     0.0500    0.0001
##     40        0.0059             nan     0.0500    0.0003
##     60        0.0029             nan     0.0500   -0.0000
##     80        0.0015             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0500    0.0010
##      2        0.0401             nan     0.0500    0.0031
##      3        0.0368             nan     0.0500    0.0030
##      4        0.0344             nan     0.0500    0.0019
##      5        0.0320             nan     0.0500    0.0011
##      6        0.0298             nan     0.0500    0.0010
##      7        0.0282             nan     0.0500   -0.0000
##      8        0.0262             nan     0.0500    0.0012
##      9        0.0246             nan     0.0500    0.0010
##     10        0.0235             nan     0.0500    0.0009
##     20        0.0140             nan     0.0500    0.0006
##     40        0.0064             nan     0.0500   -0.0000
##     60        0.0033             nan     0.0500    0.0001
##     80        0.0017             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.0500    0.0023
##      2        0.0392             nan     0.0500    0.0018
##      3        0.0368             nan     0.0500    0.0026
##      4        0.0347             nan     0.0500    0.0020
##      5        0.0329             nan     0.0500    0.0021
##      6        0.0308             nan     0.0500    0.0020
##      7        0.0286             nan     0.0500    0.0011
##      8        0.0269             nan     0.0500    0.0014
##      9        0.0265             nan     0.0500   -0.0008
##     10        0.0252             nan     0.0500    0.0012
##     20        0.0160             nan     0.0500    0.0006
##     40        0.0078             nan     0.0500    0.0001
##     60        0.0047             nan     0.0500    0.0000
##     80        0.0034             nan     0.0500   -0.0000
##    100        0.0024             nan     0.0500   -0.0001
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0013             nan     0.0500    0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0016
##      2        0.0394             nan     0.0500    0.0011
##      3        0.0375             nan     0.0500    0.0006
##      4        0.0354             nan     0.0500    0.0005
##      5        0.0321             nan     0.0500    0.0014
##      6        0.0295             nan     0.0500    0.0025
##      7        0.0280             nan     0.0500    0.0003
##      8        0.0262             nan     0.0500    0.0015
##      9        0.0241             nan     0.0500    0.0012
##     10        0.0228             nan     0.0500    0.0014
##     20        0.0118             nan     0.0500    0.0003
##     40        0.0040             nan     0.0500    0.0001
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0029
##      2        0.0384             nan     0.0500    0.0019
##      3        0.0369             nan     0.0500    0.0012
##      4        0.0346             nan     0.0500    0.0019
##      5        0.0323             nan     0.0500    0.0021
##      6        0.0299             nan     0.0500    0.0025
##      7        0.0275             nan     0.0500    0.0018
##      8        0.0262             nan     0.0500    0.0007
##      9        0.0250             nan     0.0500    0.0014
##     10        0.0232             nan     0.0500    0.0007
##     20        0.0123             nan     0.0500    0.0005
##     40        0.0044             nan     0.0500    0.0000
##     60        0.0021             nan     0.0500   -0.0000
##     80        0.0010             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0500    0.0006
##      2        0.0401             nan     0.0500    0.0030
##      3        0.0376             nan     0.0500    0.0027
##      4        0.0353             nan     0.0500    0.0010
##      5        0.0331             nan     0.0500    0.0020
##      6        0.0312             nan     0.0500    0.0007
##      7        0.0300             nan     0.0500    0.0003
##      8        0.0287             nan     0.0500    0.0007
##      9        0.0270             nan     0.0500    0.0017
##     10        0.0259             nan     0.0500    0.0007
##     20        0.0165             nan     0.0500   -0.0002
##     40        0.0084             nan     0.0500    0.0002
##     60        0.0061             nan     0.0500    0.0001
##     80        0.0042             nan     0.0500   -0.0001
##    100        0.0029             nan     0.0500    0.0000
##    120        0.0020             nan     0.0500   -0.0000
##    140        0.0015             nan     0.0500   -0.0000
##    160        0.0011             nan     0.0500   -0.0000
##    180        0.0009             nan     0.0500   -0.0000
##    200        0.0007             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0410             nan     0.0500    0.0023
##      2        0.0383             nan     0.0500    0.0022
##      3        0.0357             nan     0.0500    0.0021
##      4        0.0326             nan     0.0500    0.0018
##      5        0.0311             nan     0.0500    0.0009
##      6        0.0293             nan     0.0500    0.0003
##      7        0.0280             nan     0.0500    0.0003
##      8        0.0260             nan     0.0500    0.0013
##      9        0.0247             nan     0.0500    0.0016
##     10        0.0237             nan     0.0500    0.0007
##     20        0.0127             nan     0.0500    0.0001
##     40        0.0039             nan     0.0500   -0.0001
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0031
##      2        0.0374             nan     0.0500    0.0030
##      3        0.0355             nan     0.0500    0.0007
##      4        0.0335             nan     0.0500    0.0018
##      5        0.0312             nan     0.0500    0.0016
##      6        0.0283             nan     0.0500    0.0026
##      7        0.0266             nan     0.0500    0.0011
##      8        0.0254             nan     0.0500    0.0012
##      9        0.0236             nan     0.0500    0.0019
##     10        0.0224             nan     0.0500    0.0008
##     20        0.0122             nan     0.0500    0.0005
##     40        0.0043             nan     0.0500    0.0000
##     60        0.0018             nan     0.0500    0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.0500    0.0018
##      2        0.0396             nan     0.0500    0.0022
##      3        0.0364             nan     0.0500    0.0024
##      4        0.0339             nan     0.0500    0.0023
##      5        0.0318             nan     0.0500    0.0013
##      6        0.0302             nan     0.0500    0.0018
##      7        0.0283             nan     0.0500    0.0014
##      8        0.0270             nan     0.0500    0.0011
##      9        0.0257             nan     0.0500    0.0006
##     10        0.0247             nan     0.0500    0.0010
##     20        0.0157             nan     0.0500    0.0001
##     40        0.0082             nan     0.0500   -0.0002
##     60        0.0051             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500   -0.0000
##    100        0.0024             nan     0.0500   -0.0000
##    120        0.0016             nan     0.0500    0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000    0.0059
##      2        0.0349             nan     0.1000    0.0043
##      3        0.0321             nan     0.1000    0.0025
##      4        0.0293             nan     0.1000    0.0022
##      5        0.0259             nan     0.1000    0.0010
##      6        0.0220             nan     0.1000    0.0034
##      7        0.0211             nan     0.1000   -0.0018
##      8        0.0195             nan     0.1000    0.0010
##      9        0.0180             nan     0.1000    0.0018
##     10        0.0156             nan     0.1000    0.0017
##     20        0.0075             nan     0.1000    0.0001
##     40        0.0018             nan     0.1000    0.0000
##     60        0.0007             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.1000    0.0025
##      2        0.0344             nan     0.1000    0.0053
##      3        0.0301             nan     0.1000    0.0039
##      4        0.0267             nan     0.1000    0.0031
##      5        0.0240             nan     0.1000    0.0029
##      6        0.0226             nan     0.1000    0.0007
##      7        0.0193             nan     0.1000    0.0018
##      8        0.0170             nan     0.1000    0.0013
##      9        0.0161             nan     0.1000   -0.0004
##     10        0.0141             nan     0.1000    0.0010
##     20        0.0064             nan     0.1000   -0.0004
##     40        0.0019             nan     0.1000   -0.0000
##     60        0.0009             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000    0.0000
##    100        0.0002             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.1000    0.0045
##      2        0.0318             nan     0.1000    0.0042
##      3        0.0279             nan     0.1000    0.0034
##      4        0.0255             nan     0.1000    0.0009
##      5        0.0232             nan     0.1000    0.0017
##      6        0.0213             nan     0.1000   -0.0006
##      7        0.0196             nan     0.1000    0.0012
##      8        0.0183             nan     0.1000    0.0010
##      9        0.0175             nan     0.1000   -0.0001
##     10        0.0163             nan     0.1000    0.0014
##     20        0.0090             nan     0.1000   -0.0007
##     40        0.0045             nan     0.1000   -0.0001
##     60        0.0024             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0009             nan     0.1000    0.0000
##    120        0.0006             nan     0.1000   -0.0000
##    140        0.0004             nan     0.1000   -0.0000
##    160        0.0003             nan     0.1000   -0.0000
##    180        0.0002             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0046
##      2        0.0344             nan     0.1000   -0.0002
##      3        0.0287             nan     0.1000    0.0048
##      4        0.0249             nan     0.1000    0.0026
##      5        0.0216             nan     0.1000    0.0022
##      6        0.0191             nan     0.1000    0.0022
##      7        0.0172             nan     0.1000    0.0013
##      8        0.0150             nan     0.1000    0.0025
##      9        0.0133             nan     0.1000    0.0008
##     10        0.0117             nan     0.1000    0.0012
##     20        0.0036             nan     0.1000    0.0000
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.1000    0.0040
##      2        0.0343             nan     0.1000    0.0051
##      3        0.0296             nan     0.1000    0.0037
##      4        0.0255             nan     0.1000    0.0037
##      5        0.0240             nan     0.1000   -0.0003
##      6        0.0210             nan     0.1000    0.0029
##      7        0.0187             nan     0.1000    0.0027
##      8        0.0166             nan     0.1000    0.0010
##      9        0.0141             nan     0.1000    0.0011
##     10        0.0124             nan     0.1000    0.0018
##     20        0.0053             nan     0.1000    0.0001
##     40        0.0012             nan     0.1000   -0.0001
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0059
##      2        0.0328             nan     0.1000    0.0044
##      3        0.0317             nan     0.1000   -0.0011
##      4        0.0288             nan     0.1000    0.0017
##      5        0.0261             nan     0.1000    0.0033
##      6        0.0235             nan     0.1000    0.0029
##      7        0.0222             nan     0.1000    0.0000
##      8        0.0194             nan     0.1000    0.0017
##      9        0.0175             nan     0.1000    0.0005
##     10        0.0151             nan     0.1000    0.0012
##     20        0.0084             nan     0.1000    0.0002
##     40        0.0032             nan     0.1000    0.0000
##     60        0.0015             nan     0.1000    0.0000
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0389             nan     0.1000    0.0030
##      2        0.0347             nan     0.1000    0.0020
##      3        0.0305             nan     0.1000    0.0041
##      4        0.0247             nan     0.1000    0.0055
##      5        0.0217             nan     0.1000    0.0028
##      6        0.0192             nan     0.1000    0.0018
##      7        0.0164             nan     0.1000    0.0033
##      8        0.0151             nan     0.1000    0.0011
##      9        0.0135             nan     0.1000    0.0014
##     10        0.0122             nan     0.1000    0.0008
##     20        0.0034             nan     0.1000    0.0006
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.1000   -0.0013
##      2        0.0360             nan     0.1000    0.0049
##      3        0.0316             nan     0.1000    0.0048
##      4        0.0275             nan     0.1000    0.0039
##      5        0.0238             nan     0.1000    0.0034
##      6        0.0196             nan     0.1000    0.0021
##      7        0.0172             nan     0.1000    0.0015
##      8        0.0151             nan     0.1000    0.0018
##      9        0.0134             nan     0.1000    0.0015
##     10        0.0115             nan     0.1000    0.0009
##     20        0.0033             nan     0.1000   -0.0000
##     40        0.0009             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0059
##      2        0.0337             nan     0.1000    0.0037
##      3        0.0292             nan     0.1000    0.0029
##      4        0.0268             nan     0.1000    0.0005
##      5        0.0252             nan     0.1000    0.0014
##      6        0.0221             nan     0.1000    0.0031
##      7        0.0199             nan     0.1000    0.0023
##      8        0.0174             nan     0.1000    0.0020
##      9        0.0161             nan     0.1000    0.0007
##     10        0.0144             nan     0.1000    0.0016
##     20        0.0084             nan     0.1000   -0.0005
##     40        0.0028             nan     0.1000    0.0001
##     60        0.0013             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0001
##      2        0.0427             nan     0.0100    0.0004
##      3        0.0422             nan     0.0100    0.0003
##      4        0.0418             nan     0.0100    0.0002
##      5        0.0412             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0004
##      7        0.0401             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0390             nan     0.0100    0.0005
##     10        0.0385             nan     0.0100    0.0003
##     20        0.0343             nan     0.0100    0.0004
##     40        0.0277             nan     0.0100    0.0001
##     60        0.0221             nan     0.0100    0.0003
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0147             nan     0.0100    0.0000
##    120        0.0121             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0000
##    160        0.0083             nan     0.0100    0.0001
##    180        0.0069             nan     0.0100    0.0000
##    200        0.0060             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0006
##      2        0.0425             nan     0.0100    0.0001
##      3        0.0419             nan     0.0100    0.0005
##      4        0.0415             nan     0.0100    0.0004
##      5        0.0409             nan     0.0100    0.0006
##      6        0.0404             nan     0.0100    0.0004
##      7        0.0399             nan     0.0100    0.0004
##      8        0.0394             nan     0.0100    0.0005
##      9        0.0388             nan     0.0100    0.0003
##     10        0.0385             nan     0.0100    0.0004
##     20        0.0339             nan     0.0100    0.0003
##     40        0.0275             nan     0.0100    0.0002
##     60        0.0220             nan     0.0100    0.0001
##     80        0.0179             nan     0.0100    0.0002
##    100        0.0147             nan     0.0100    0.0002
##    120        0.0122             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0085             nan     0.0100   -0.0000
##    180        0.0074             nan     0.0100    0.0001
##    200        0.0063             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0006
##      2        0.0424             nan     0.0100    0.0002
##      3        0.0420             nan     0.0100    0.0004
##      4        0.0415             nan     0.0100    0.0005
##      5        0.0411             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0002
##      7        0.0405             nan     0.0100    0.0001
##      8        0.0401             nan     0.0100    0.0003
##      9        0.0395             nan     0.0100    0.0005
##     10        0.0391             nan     0.0100    0.0005
##     20        0.0347             nan     0.0100    0.0001
##     40        0.0282             nan     0.0100    0.0003
##     60        0.0232             nan     0.0100    0.0002
##     80        0.0196             nan     0.0100    0.0000
##    100        0.0165             nan     0.0100    0.0001
##    120        0.0141             nan     0.0100   -0.0000
##    140        0.0123             nan     0.0100   -0.0000
##    160        0.0108             nan     0.0100    0.0000
##    180        0.0096             nan     0.0100    0.0001
##    200        0.0084             nan     0.0100   -0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0004
##      2        0.0422             nan     0.0100    0.0006
##      3        0.0414             nan     0.0100    0.0007
##      4        0.0411             nan     0.0100    0.0000
##      5        0.0403             nan     0.0100    0.0005
##      6        0.0399             nan     0.0100    0.0002
##      7        0.0393             nan     0.0100    0.0004
##      8        0.0387             nan     0.0100    0.0004
##      9        0.0381             nan     0.0100    0.0006
##     10        0.0374             nan     0.0100    0.0004
##     20        0.0329             nan     0.0100    0.0003
##     40        0.0253             nan     0.0100    0.0001
##     60        0.0191             nan     0.0100    0.0002
##     80        0.0149             nan     0.0100    0.0000
##    100        0.0119             nan     0.0100    0.0001
##    120        0.0092             nan     0.0100    0.0000
##    140        0.0074             nan     0.0100   -0.0000
##    160        0.0059             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100    0.0000
##    200        0.0037             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0003
##      2        0.0424             nan     0.0100    0.0007
##      3        0.0417             nan     0.0100    0.0007
##      4        0.0411             nan     0.0100    0.0006
##      5        0.0406             nan     0.0100    0.0005
##      6        0.0402             nan     0.0100    0.0005
##      7        0.0397             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100   -0.0000
##      9        0.0390             nan     0.0100    0.0001
##     10        0.0386             nan     0.0100    0.0002
##     20        0.0333             nan     0.0100    0.0004
##     40        0.0261             nan     0.0100    0.0003
##     60        0.0198             nan     0.0100    0.0003
##     80        0.0155             nan     0.0100    0.0001
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0080             nan     0.0100    0.0000
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0052             nan     0.0100    0.0000
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0005
##      2        0.0426             nan     0.0100    0.0003
##      3        0.0421             nan     0.0100    0.0005
##      4        0.0416             nan     0.0100    0.0003
##      5        0.0411             nan     0.0100    0.0006
##      6        0.0406             nan     0.0100    0.0002
##      7        0.0402             nan     0.0100    0.0003
##      8        0.0398             nan     0.0100    0.0005
##      9        0.0393             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0005
##     20        0.0352             nan     0.0100    0.0003
##     40        0.0287             nan     0.0100    0.0000
##     60        0.0237             nan     0.0100    0.0000
##     80        0.0202             nan     0.0100   -0.0001
##    100        0.0170             nan     0.0100    0.0001
##    120        0.0145             nan     0.0100   -0.0001
##    140        0.0127             nan     0.0100    0.0000
##    160        0.0111             nan     0.0100   -0.0000
##    180        0.0099             nan     0.0100   -0.0000
##    200        0.0089             nan     0.0100   -0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0005
##      2        0.0422             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100    0.0006
##      4        0.0411             nan     0.0100    0.0006
##      5        0.0404             nan     0.0100    0.0003
##      6        0.0398             nan     0.0100    0.0004
##      7        0.0390             nan     0.0100    0.0007
##      8        0.0383             nan     0.0100    0.0009
##      9        0.0377             nan     0.0100    0.0004
##     10        0.0370             nan     0.0100    0.0004
##     20        0.0315             nan     0.0100    0.0002
##     40        0.0239             nan     0.0100    0.0002
##     60        0.0178             nan     0.0100    0.0002
##     80        0.0134             nan     0.0100    0.0002
##    100        0.0103             nan     0.0100    0.0001
##    120        0.0081             nan     0.0100    0.0000
##    140        0.0064             nan     0.0100    0.0001
##    160        0.0050             nan     0.0100    0.0001
##    180        0.0040             nan     0.0100    0.0000
##    200        0.0032             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0007
##      2        0.0425             nan     0.0100    0.0004
##      3        0.0419             nan     0.0100    0.0005
##      4        0.0415             nan     0.0100    0.0002
##      5        0.0410             nan     0.0100    0.0005
##      6        0.0404             nan     0.0100    0.0006
##      7        0.0397             nan     0.0100    0.0006
##      8        0.0391             nan     0.0100    0.0005
##      9        0.0386             nan     0.0100    0.0003
##     10        0.0381             nan     0.0100    0.0003
##     20        0.0332             nan     0.0100    0.0004
##     40        0.0253             nan     0.0100    0.0001
##     60        0.0197             nan     0.0100    0.0002
##     80        0.0155             nan     0.0100    0.0000
##    100        0.0118             nan     0.0100    0.0002
##    120        0.0092             nan     0.0100    0.0001
##    140        0.0073             nan     0.0100    0.0000
##    160        0.0059             nan     0.0100    0.0000
##    180        0.0049             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0004
##      2        0.0425             nan     0.0100    0.0006
##      3        0.0421             nan     0.0100    0.0002
##      4        0.0414             nan     0.0100    0.0006
##      5        0.0408             nan     0.0100    0.0005
##      6        0.0404             nan     0.0100    0.0004
##      7        0.0401             nan     0.0100    0.0002
##      8        0.0395             nan     0.0100    0.0004
##      9        0.0392             nan     0.0100    0.0001
##     10        0.0390             nan     0.0100    0.0000
##     20        0.0342             nan     0.0100   -0.0000
##     40        0.0277             nan     0.0100    0.0002
##     60        0.0226             nan     0.0100    0.0002
##     80        0.0187             nan     0.0100    0.0000
##    100        0.0158             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100    0.0000
##    140        0.0115             nan     0.0100    0.0001
##    160        0.0104             nan     0.0100    0.0001
##    180        0.0090             nan     0.0100   -0.0000
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0025
##      2        0.0387             nan     0.0500    0.0022
##      3        0.0367             nan     0.0500    0.0023
##      4        0.0339             nan     0.0500    0.0021
##      5        0.0324             nan     0.0500    0.0011
##      6        0.0311             nan     0.0500    0.0007
##      7        0.0298             nan     0.0500    0.0006
##      8        0.0282             nan     0.0500    0.0015
##      9        0.0267             nan     0.0500    0.0015
##     10        0.0252             nan     0.0500    0.0011
##     20        0.0156             nan     0.0500   -0.0000
##     40        0.0067             nan     0.0500    0.0003
##     60        0.0037             nan     0.0500    0.0001
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0010             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0028
##      2        0.0385             nan     0.0500    0.0025
##      3        0.0355             nan     0.0500    0.0019
##      4        0.0338             nan     0.0500    0.0016
##      5        0.0312             nan     0.0500    0.0014
##      6        0.0294             nan     0.0500    0.0016
##      7        0.0276             nan     0.0500    0.0013
##      8        0.0266             nan     0.0500    0.0004
##      9        0.0253             nan     0.0500    0.0006
##     10        0.0240             nan     0.0500    0.0011
##     20        0.0149             nan     0.0500    0.0003
##     40        0.0064             nan     0.0500    0.0001
##     60        0.0032             nan     0.0500    0.0000
##     80        0.0018             nan     0.0500   -0.0000
##    100        0.0012             nan     0.0500   -0.0001
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0410             nan     0.0500    0.0019
##      2        0.0390             nan     0.0500    0.0018
##      3        0.0363             nan     0.0500    0.0022
##      4        0.0344             nan     0.0500    0.0022
##      5        0.0320             nan     0.0500    0.0014
##      6        0.0309             nan     0.0500    0.0005
##      7        0.0290             nan     0.0500    0.0017
##      8        0.0275             nan     0.0500    0.0013
##      9        0.0260             nan     0.0500    0.0013
##     10        0.0243             nan     0.0500    0.0009
##     20        0.0160             nan     0.0500    0.0004
##     40        0.0103             nan     0.0500    0.0002
##     60        0.0059             nan     0.0500    0.0002
##     80        0.0034             nan     0.0500   -0.0000
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0017             nan     0.0500   -0.0001
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500    0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0500    0.0025
##      2        0.0384             nan     0.0500    0.0007
##      3        0.0361             nan     0.0500    0.0019
##      4        0.0352             nan     0.0500   -0.0006
##      5        0.0333             nan     0.0500    0.0003
##      6        0.0308             nan     0.0500    0.0008
##      7        0.0284             nan     0.0500    0.0016
##      8        0.0264             nan     0.0500    0.0016
##      9        0.0257             nan     0.0500    0.0002
##     10        0.0243             nan     0.0500    0.0015
##     20        0.0142             nan     0.0500    0.0008
##     40        0.0046             nan     0.0500    0.0001
##     60        0.0018             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0031
##      2        0.0372             nan     0.0500    0.0023
##      3        0.0339             nan     0.0500    0.0026
##      4        0.0324             nan     0.0500    0.0011
##      5        0.0299             nan     0.0500    0.0016
##      6        0.0280             nan     0.0500    0.0018
##      7        0.0270             nan     0.0500    0.0004
##      8        0.0261             nan     0.0500    0.0006
##      9        0.0245             nan     0.0500    0.0009
##     10        0.0236             nan     0.0500    0.0008
##     20        0.0136             nan     0.0500    0.0003
##     40        0.0047             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0500    0.0003
##      2        0.0394             nan     0.0500    0.0025
##      3        0.0373             nan     0.0500    0.0018
##      4        0.0357             nan     0.0500    0.0020
##      5        0.0335             nan     0.0500    0.0014
##      6        0.0315             nan     0.0500    0.0011
##      7        0.0302             nan     0.0500    0.0004
##      8        0.0288             nan     0.0500    0.0006
##      9        0.0270             nan     0.0500    0.0017
##     10        0.0267             nan     0.0500   -0.0005
##     20        0.0176             nan     0.0500    0.0005
##     40        0.0088             nan     0.0500   -0.0003
##     60        0.0053             nan     0.0500   -0.0001
##     80        0.0033             nan     0.0500    0.0001
##    100        0.0023             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0500    0.0006
##      2        0.0369             nan     0.0500    0.0030
##      3        0.0350             nan     0.0500    0.0004
##      4        0.0328             nan     0.0500    0.0018
##      5        0.0305             nan     0.0500    0.0027
##      6        0.0285             nan     0.0500    0.0008
##      7        0.0260             nan     0.0500    0.0010
##      8        0.0241             nan     0.0500    0.0013
##      9        0.0221             nan     0.0500    0.0015
##     10        0.0205             nan     0.0500    0.0014
##     20        0.0109             nan     0.0500    0.0001
##     40        0.0036             nan     0.0500    0.0000
##     60        0.0012             nan     0.0500    0.0001
##     80        0.0004             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0029
##      2        0.0387             nan     0.0500    0.0015
##      3        0.0355             nan     0.0500    0.0025
##      4        0.0344             nan     0.0500    0.0008
##      5        0.0319             nan     0.0500    0.0024
##      6        0.0301             nan     0.0500    0.0012
##      7        0.0280             nan     0.0500    0.0010
##      8        0.0259             nan     0.0500    0.0002
##      9        0.0249             nan     0.0500    0.0007
##     10        0.0231             nan     0.0500    0.0007
##     20        0.0127             nan     0.0500    0.0001
##     40        0.0039             nan     0.0500   -0.0000
##     60        0.0017             nan     0.0500   -0.0000
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0019
##      2        0.0390             nan     0.0500    0.0016
##      3        0.0386             nan     0.0500   -0.0012
##      4        0.0359             nan     0.0500    0.0025
##      5        0.0338             nan     0.0500    0.0018
##      6        0.0324             nan     0.0500    0.0012
##      7        0.0311             nan     0.0500    0.0006
##      8        0.0298             nan     0.0500    0.0016
##      9        0.0281             nan     0.0500    0.0011
##     10        0.0273             nan     0.0500   -0.0000
##     20        0.0188             nan     0.0500    0.0003
##     40        0.0102             nan     0.0500   -0.0000
##     60        0.0061             nan     0.0500   -0.0001
##     80        0.0038             nan     0.0500   -0.0000
##    100        0.0027             nan     0.0500   -0.0000
##    120        0.0019             nan     0.0500   -0.0001
##    140        0.0014             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0056
##      2        0.0334             nan     0.1000    0.0021
##      3        0.0292             nan     0.1000    0.0040
##      4        0.0255             nan     0.1000    0.0032
##      5        0.0241             nan     0.1000    0.0005
##      6        0.0223             nan     0.1000    0.0018
##      7        0.0202             nan     0.1000    0.0021
##      8        0.0186             nan     0.1000    0.0002
##      9        0.0165             nan     0.1000    0.0018
##     10        0.0153             nan     0.1000    0.0009
##     20        0.0060             nan     0.1000    0.0004
##     40        0.0016             nan     0.1000   -0.0001
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0040
##      2        0.0343             nan     0.1000    0.0042
##      3        0.0309             nan     0.1000    0.0005
##      4        0.0279             nan     0.1000    0.0017
##      5        0.0250             nan     0.1000    0.0019
##      6        0.0229             nan     0.1000   -0.0004
##      7        0.0204             nan     0.1000    0.0011
##      8        0.0192             nan     0.1000    0.0002
##      9        0.0180             nan     0.1000    0.0012
##     10        0.0156             nan     0.1000    0.0012
##     20        0.0070             nan     0.1000    0.0001
##     40        0.0019             nan     0.1000    0.0000
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.1000    0.0054
##      2        0.0343             nan     0.1000    0.0027
##      3        0.0299             nan     0.1000    0.0022
##      4        0.0265             nan     0.1000    0.0030
##      5        0.0247             nan     0.1000    0.0008
##      6        0.0216             nan     0.1000    0.0029
##      7        0.0199             nan     0.1000    0.0008
##      8        0.0177             nan     0.1000    0.0021
##      9        0.0160             nan     0.1000    0.0017
##     10        0.0148             nan     0.1000    0.0007
##     20        0.0085             nan     0.1000    0.0001
##     40        0.0036             nan     0.1000   -0.0003
##     60        0.0012             nan     0.1000   -0.0001
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0045
##      2        0.0332             nan     0.1000    0.0036
##      3        0.0297             nan     0.1000    0.0017
##      4        0.0259             nan     0.1000    0.0009
##      5        0.0228             nan     0.1000    0.0024
##      6        0.0198             nan     0.1000    0.0018
##      7        0.0180             nan     0.1000    0.0012
##      8        0.0166             nan     0.1000    0.0008
##      9        0.0140             nan     0.1000    0.0012
##     10        0.0126             nan     0.1000    0.0014
##     20        0.0039             nan     0.1000    0.0003
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.1000    0.0003
##      2        0.0322             nan     0.1000    0.0050
##      3        0.0284             nan     0.1000    0.0043
##      4        0.0251             nan     0.1000    0.0032
##      5        0.0225             nan     0.1000    0.0019
##      6        0.0198             nan     0.1000    0.0029
##      7        0.0172             nan     0.1000    0.0017
##      8        0.0162             nan     0.1000   -0.0002
##      9        0.0149             nan     0.1000   -0.0012
##     10        0.0140             nan     0.1000    0.0005
##     20        0.0048             nan     0.1000   -0.0000
##     40        0.0011             nan     0.1000   -0.0001
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0054
##      2        0.0341             nan     0.1000    0.0035
##      3        0.0307             nan     0.1000    0.0037
##      4        0.0278             nan     0.1000    0.0000
##      5        0.0253             nan     0.1000    0.0002
##      6        0.0228             nan     0.1000    0.0026
##      7        0.0204             nan     0.1000    0.0020
##      8        0.0186             nan     0.1000    0.0007
##      9        0.0178             nan     0.1000   -0.0004
##     10        0.0159             nan     0.1000    0.0007
##     20        0.0079             nan     0.1000    0.0001
##     40        0.0027             nan     0.1000   -0.0001
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0048
##      2        0.0333             nan     0.1000    0.0027
##      3        0.0281             nan     0.1000    0.0024
##      4        0.0242             nan     0.1000    0.0024
##      5        0.0210             nan     0.1000    0.0032
##      6        0.0172             nan     0.1000    0.0022
##      7        0.0139             nan     0.1000    0.0022
##      8        0.0125             nan     0.1000    0.0008
##      9        0.0111             nan     0.1000    0.0014
##     10        0.0096             nan     0.1000    0.0007
##     20        0.0025             nan     0.1000    0.0002
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.1000    0.0043
##      2        0.0314             nan     0.1000    0.0050
##      3        0.0283             nan     0.1000   -0.0017
##      4        0.0248             nan     0.1000    0.0030
##      5        0.0230             nan     0.1000    0.0007
##      6        0.0200             nan     0.1000    0.0027
##      7        0.0191             nan     0.1000   -0.0009
##      8        0.0163             nan     0.1000    0.0009
##      9        0.0149             nan     0.1000    0.0015
##     10        0.0134             nan     0.1000    0.0010
##     20        0.0053             nan     0.1000   -0.0003
##     40        0.0014             nan     0.1000    0.0001
##     60        0.0005             nan     0.1000   -0.0001
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.1000   -0.0008
##      2        0.0365             nan     0.1000    0.0054
##      3        0.0321             nan     0.1000    0.0046
##      4        0.0283             nan     0.1000    0.0036
##      5        0.0246             nan     0.1000    0.0025
##      6        0.0220             nan     0.1000    0.0025
##      7        0.0204             nan     0.1000    0.0002
##      8        0.0190             nan     0.1000    0.0007
##      9        0.0169             nan     0.1000    0.0014
##     10        0.0156             nan     0.1000    0.0009
##     20        0.0092             nan     0.1000    0.0001
##     40        0.0043             nan     0.1000   -0.0001
##     60        0.0020             nan     0.1000   -0.0000
##     80        0.0011             nan     0.1000   -0.0001
##    100        0.0007             nan     0.1000    0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0005
##      2        0.0424             nan     0.0100   -0.0000
##      3        0.0418             nan     0.0100    0.0003
##      4        0.0415             nan     0.0100    0.0003
##      5        0.0409             nan     0.0100    0.0003
##      6        0.0406             nan     0.0100    0.0001
##      7        0.0401             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0006
##      9        0.0389             nan     0.0100    0.0006
##     10        0.0384             nan     0.0100    0.0005
##     20        0.0344             nan     0.0100    0.0004
##     40        0.0279             nan     0.0100    0.0004
##     60        0.0230             nan     0.0100    0.0002
##     80        0.0185             nan     0.0100    0.0002
##    100        0.0155             nan     0.0100    0.0000
##    120        0.0127             nan     0.0100    0.0000
##    140        0.0107             nan     0.0100    0.0001
##    160        0.0090             nan     0.0100    0.0001
##    180        0.0077             nan     0.0100    0.0000
##    200        0.0064             nan     0.0100    0.0001
## 
## - Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0002
##      2        0.0421             nan     0.0100    0.0002
##      3        0.0415             nan     0.0100    0.0006
##      4        0.0412             nan     0.0100   -0.0000
##      5        0.0407             nan     0.0100    0.0005
##      6        0.0400             nan     0.0100    0.0005
##      7        0.0395             nan     0.0100    0.0003
##      8        0.0391             nan     0.0100    0.0005
##      9        0.0385             nan     0.0100    0.0004
##     10        0.0381             nan     0.0100    0.0003
##     20        0.0336             nan     0.0100    0.0001
##     40        0.0272             nan     0.0100    0.0003
##     60        0.0225             nan     0.0100    0.0000
##     80        0.0186             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0129             nan     0.0100    0.0001
##    140        0.0110             nan     0.0100   -0.0000
##    160        0.0094             nan     0.0100    0.0000
##    180        0.0077             nan     0.0100    0.0000
##    200        0.0066             nan     0.0100    0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0006
##      2        0.0418             nan     0.0100    0.0005
##      3        0.0412             nan     0.0100    0.0005
##      4        0.0409             nan     0.0100    0.0000
##      5        0.0404             nan     0.0100    0.0005
##      6        0.0400             nan     0.0100    0.0000
##      7        0.0396             nan     0.0100    0.0002
##      8        0.0391             nan     0.0100    0.0003
##      9        0.0386             nan     0.0100    0.0005
##     10        0.0383             nan     0.0100    0.0001
##     20        0.0344             nan     0.0100    0.0004
##     40        0.0271             nan     0.0100    0.0002
##     60        0.0225             nan     0.0100    0.0001
##     80        0.0190             nan     0.0100    0.0002
##    100        0.0161             nan     0.0100   -0.0000
##    120        0.0140             nan     0.0100    0.0001
##    140        0.0125             nan     0.0100   -0.0000
##    160        0.0110             nan     0.0100   -0.0000
##    180        0.0095             nan     0.0100    0.0001
##    200        0.0085             nan     0.0100   -0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0005
##      2        0.0419             nan     0.0100    0.0006
##      3        0.0411             nan     0.0100    0.0007
##      4        0.0405             nan     0.0100    0.0004
##      5        0.0400             nan     0.0100    0.0003
##      6        0.0394             nan     0.0100    0.0004
##      7        0.0389             nan     0.0100    0.0004
##      8        0.0386             nan     0.0100    0.0002
##      9        0.0380             nan     0.0100    0.0007
##     10        0.0373             nan     0.0100    0.0005
##     20        0.0319             nan     0.0100    0.0003
##     40        0.0246             nan     0.0100    0.0002
##     60        0.0186             nan     0.0100    0.0001
##     80        0.0146             nan     0.0100    0.0001
##    100        0.0115             nan     0.0100   -0.0000
##    120        0.0090             nan     0.0100    0.0001
##    140        0.0072             nan     0.0100    0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100    0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100   -0.0003
##      2        0.0419             nan     0.0100    0.0006
##      3        0.0412             nan     0.0100    0.0007
##      4        0.0406             nan     0.0100    0.0005
##      5        0.0399             nan     0.0100    0.0007
##      6        0.0393             nan     0.0100    0.0004
##      7        0.0388             nan     0.0100    0.0003
##      8        0.0383             nan     0.0100    0.0003
##      9        0.0378             nan     0.0100    0.0002
##     10        0.0372             nan     0.0100    0.0005
##     20        0.0327             nan     0.0100    0.0003
##     40        0.0248             nan     0.0100    0.0003
##     60        0.0196             nan     0.0100    0.0002
##     80        0.0156             nan     0.0100    0.0002
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0100             nan     0.0100    0.0001
##    140        0.0083             nan     0.0100    0.0001
##    160        0.0066             nan     0.0100   -0.0000
##    180        0.0054             nan     0.0100    0.0000
##    200        0.0046             nan     0.0100    0.0001
## 
## - Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0005
##      2        0.0421             nan     0.0100    0.0003
##      3        0.0416             nan     0.0100    0.0004
##      4        0.0411             nan     0.0100    0.0003
##      5        0.0407             nan     0.0100    0.0004
##      6        0.0401             nan     0.0100    0.0005
##      7        0.0396             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100   -0.0001
##      9        0.0391             nan     0.0100    0.0002
##     10        0.0388             nan     0.0100   -0.0000
##     20        0.0348             nan     0.0100    0.0005
##     40        0.0279             nan     0.0100    0.0003
##     60        0.0228             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0159             nan     0.0100   -0.0001
##    120        0.0138             nan     0.0100   -0.0000
##    140        0.0121             nan     0.0100    0.0000
##    160        0.0108             nan     0.0100   -0.0000
##    180        0.0094             nan     0.0100    0.0000
##    200        0.0086             nan     0.0100   -0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0008
##      2        0.0418             nan     0.0100    0.0006
##      3        0.0411             nan     0.0100    0.0005
##      4        0.0404             nan     0.0100    0.0004
##      5        0.0401             nan     0.0100   -0.0001
##      6        0.0394             nan     0.0100    0.0007
##      7        0.0387             nan     0.0100    0.0007
##      8        0.0382             nan     0.0100    0.0005
##      9        0.0378             nan     0.0100    0.0001
##     10        0.0372             nan     0.0100    0.0005
##     20        0.0316             nan     0.0100    0.0003
##     40        0.0239             nan     0.0100    0.0003
##     60        0.0184             nan     0.0100    0.0002
##     80        0.0138             nan     0.0100    0.0002
##    100        0.0107             nan     0.0100    0.0001
##    120        0.0084             nan     0.0100    0.0000
##    140        0.0066             nan     0.0100   -0.0000
##    160        0.0053             nan     0.0100    0.0000
##    180        0.0043             nan     0.0100    0.0000
##    200        0.0034             nan     0.0100    0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0006
##      2        0.0417             nan     0.0100    0.0006
##      3        0.0411             nan     0.0100    0.0002
##      4        0.0406             nan     0.0100    0.0002
##      5        0.0401             nan     0.0100    0.0005
##      6        0.0395             nan     0.0100    0.0004
##      7        0.0389             nan     0.0100    0.0006
##      8        0.0384             nan     0.0100    0.0003
##      9        0.0377             nan     0.0100    0.0008
##     10        0.0371             nan     0.0100    0.0004
##     20        0.0325             nan     0.0100    0.0004
##     40        0.0243             nan     0.0100    0.0002
##     60        0.0185             nan     0.0100    0.0002
##     80        0.0146             nan     0.0100    0.0002
##    100        0.0118             nan     0.0100    0.0001
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0076             nan     0.0100    0.0000
##    160        0.0065             nan     0.0100    0.0000
##    180        0.0053             nan     0.0100   -0.0000
##    200        0.0045             nan     0.0100    0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0006
##      2        0.0417             nan     0.0100    0.0006
##      3        0.0412             nan     0.0100    0.0006
##      4        0.0411             nan     0.0100    0.0000
##      5        0.0408             nan     0.0100   -0.0001
##      6        0.0403             nan     0.0100    0.0005
##      7        0.0398             nan     0.0100    0.0005
##      8        0.0392             nan     0.0100    0.0004
##      9        0.0387             nan     0.0100    0.0005
##     10        0.0383             nan     0.0100    0.0000
##     20        0.0342             nan     0.0100    0.0004
##     40        0.0275             nan     0.0100    0.0002
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0187             nan     0.0100    0.0002
##    100        0.0156             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0117             nan     0.0100    0.0001
##    160        0.0102             nan     0.0100    0.0001
##    180        0.0089             nan     0.0100   -0.0000
##    200        0.0078             nan     0.0100   -0.0000
## 
## - Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0003
##      2        0.0387             nan     0.0500    0.0019
##      3        0.0358             nan     0.0500    0.0026
##      4        0.0336             nan     0.0500    0.0017
##      5        0.0318             nan     0.0500    0.0006
##      6        0.0298             nan     0.0500    0.0017
##      7        0.0280             nan     0.0500    0.0023
##      8        0.0269             nan     0.0500    0.0007
##      9        0.0251             nan     0.0500    0.0016
##     10        0.0242             nan     0.0500    0.0005
##     20        0.0141             nan     0.0500    0.0002
##     40        0.0060             nan     0.0500    0.0000
##     60        0.0026             nan     0.0500   -0.0000
##     80        0.0013             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0004             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0400             nan     0.0500    0.0027
##      2        0.0374             nan     0.0500    0.0024
##      3        0.0353             nan     0.0500    0.0017
##      4        0.0327             nan     0.0500    0.0021
##      5        0.0302             nan     0.0500    0.0020
##      6        0.0279             nan     0.0500    0.0023
##      7        0.0262             nan     0.0500    0.0013
##      8        0.0256             nan     0.0500   -0.0004
##      9        0.0253             nan     0.0500   -0.0003
##     10        0.0234             nan     0.0500    0.0006
##     20        0.0143             nan     0.0500    0.0007
##     40        0.0058             nan     0.0500    0.0001
##     60        0.0030             nan     0.0500   -0.0000
##     80        0.0017             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0023
##      2        0.0375             nan     0.0500    0.0026
##      3        0.0351             nan     0.0500    0.0021
##      4        0.0332             nan     0.0500    0.0021
##      5        0.0317             nan     0.0500    0.0016
##      6        0.0297             nan     0.0500    0.0020
##      7        0.0280             nan     0.0500    0.0017
##      8        0.0260             nan     0.0500    0.0011
##      9        0.0246             nan     0.0500    0.0013
##     10        0.0234             nan     0.0500    0.0008
##     20        0.0155             nan     0.0500    0.0003
##     40        0.0090             nan     0.0500   -0.0003
##     60        0.0053             nan     0.0500   -0.0001
##     80        0.0036             nan     0.0500   -0.0000
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0018             nan     0.0500   -0.0000
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.0500    0.0013
##      2        0.0383             nan     0.0500   -0.0002
##      3        0.0359             nan     0.0500    0.0017
##      4        0.0331             nan     0.0500    0.0021
##      5        0.0308             nan     0.0500    0.0016
##      6        0.0299             nan     0.0500    0.0006
##      7        0.0281             nan     0.0500    0.0013
##      8        0.0259             nan     0.0500    0.0017
##      9        0.0250             nan     0.0500    0.0009
##     10        0.0236             nan     0.0500    0.0011
##     20        0.0127             nan     0.0500    0.0008
##     40        0.0044             nan     0.0500    0.0002
##     60        0.0015             nan     0.0500    0.0001
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0419             nan     0.0500    0.0005
##      2        0.0390             nan     0.0500    0.0017
##      3        0.0368             nan     0.0500    0.0016
##      4        0.0339             nan     0.0500    0.0012
##      5        0.0321             nan     0.0500    0.0002
##      6        0.0294             nan     0.0500    0.0012
##      7        0.0275             nan     0.0500    0.0012
##      8        0.0251             nan     0.0500    0.0019
##      9        0.0243             nan     0.0500    0.0003
##     10        0.0227             nan     0.0500    0.0013
##     20        0.0142             nan     0.0500    0.0005
##     40        0.0055             nan     0.0500   -0.0000
##     60        0.0025             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0030
##      2        0.0374             nan     0.0500    0.0009
##      3        0.0360             nan     0.0500    0.0013
##      4        0.0334             nan     0.0500    0.0018
##      5        0.0319             nan     0.0500    0.0001
##      6        0.0298             nan     0.0500    0.0017
##      7        0.0285             nan     0.0500    0.0009
##      8        0.0270             nan     0.0500    0.0010
##      9        0.0255             nan     0.0500    0.0017
##     10        0.0241             nan     0.0500    0.0015
##     20        0.0151             nan     0.0500    0.0002
##     40        0.0087             nan     0.0500   -0.0001
##     60        0.0056             nan     0.0500    0.0000
##     80        0.0035             nan     0.0500    0.0000
##    100        0.0024             nan     0.0500   -0.0001
##    120        0.0018             nan     0.0500    0.0000
##    140        0.0013             nan     0.0500    0.0000
##    160        0.0011             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500   -0.0000
##    200        0.0007             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0015
##      2        0.0387             nan     0.0500    0.0032
##      3        0.0372             nan     0.0500   -0.0006
##      4        0.0348             nan     0.0500    0.0021
##      5        0.0337             nan     0.0500   -0.0001
##      6        0.0317             nan     0.0500    0.0007
##      7        0.0301             nan     0.0500    0.0005
##      8        0.0281             nan     0.0500    0.0005
##      9        0.0260             nan     0.0500    0.0017
##     10        0.0237             nan     0.0500    0.0009
##     20        0.0121             nan     0.0500    0.0006
##     40        0.0036             nan     0.0500    0.0001
##     60        0.0013             nan     0.0500   -0.0001
##     80        0.0006             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0023
##      2        0.0365             nan     0.0500    0.0027
##      3        0.0345             nan     0.0500    0.0005
##      4        0.0320             nan     0.0500    0.0016
##      5        0.0299             nan     0.0500    0.0020
##      6        0.0283             nan     0.0500    0.0007
##      7        0.0270             nan     0.0500    0.0006
##      8        0.0252             nan     0.0500    0.0017
##      9        0.0234             nan     0.0500    0.0016
##     10        0.0213             nan     0.0500    0.0015
##     20        0.0108             nan     0.0500    0.0008
##     40        0.0037             nan     0.0500    0.0001
##     60        0.0016             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0027
##      2        0.0392             nan     0.0500    0.0001
##      3        0.0365             nan     0.0500    0.0019
##      4        0.0348             nan     0.0500    0.0017
##      5        0.0328             nan     0.0500    0.0015
##      6        0.0308             nan     0.0500    0.0016
##      7        0.0294             nan     0.0500    0.0014
##      8        0.0287             nan     0.0500    0.0005
##      9        0.0271             nan     0.0500    0.0003
##     10        0.0254             nan     0.0500    0.0014
##     20        0.0163             nan     0.0500    0.0007
##     40        0.0079             nan     0.0500    0.0002
##     60        0.0044             nan     0.0500    0.0000
##     80        0.0028             nan     0.0500   -0.0000
##    100        0.0019             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0055
##      2        0.0338             nan     0.1000    0.0043
##      3        0.0285             nan     0.1000    0.0037
##      4        0.0256             nan     0.1000    0.0012
##      5        0.0227             nan     0.1000    0.0024
##      6        0.0206             nan     0.1000    0.0025
##      7        0.0186             nan     0.1000    0.0019
##      8        0.0164             nan     0.1000    0.0011
##      9        0.0149             nan     0.1000    0.0011
##     10        0.0140             nan     0.1000    0.0005
##     20        0.0068             nan     0.1000    0.0001
##     40        0.0015             nan     0.1000   -0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.1000    0.0050
##      2        0.0333             nan     0.1000    0.0047
##      3        0.0289             nan     0.1000    0.0037
##      4        0.0260             nan     0.1000    0.0025
##      5        0.0229             nan     0.1000    0.0020
##      6        0.0200             nan     0.1000    0.0016
##      7        0.0177             nan     0.1000    0.0017
##      8        0.0164             nan     0.1000    0.0014
##      9        0.0147             nan     0.1000    0.0015
##     10        0.0133             nan     0.1000   -0.0003
##     20        0.0063             nan     0.1000    0.0001
##     40        0.0022             nan     0.1000    0.0000
##     60        0.0010             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0056
##      2        0.0333             nan     0.1000    0.0022
##      3        0.0296             nan     0.1000    0.0037
##      4        0.0269             nan     0.1000    0.0025
##      5        0.0248             nan     0.1000    0.0022
##      6        0.0229             nan     0.1000    0.0014
##      7        0.0213             nan     0.1000    0.0002
##      8        0.0191             nan     0.1000    0.0017
##      9        0.0180             nan     0.1000    0.0008
##     10        0.0155             nan     0.1000    0.0015
##     20        0.0077             nan     0.1000   -0.0000
##     40        0.0037             nan     0.1000    0.0001
##     60        0.0018             nan     0.1000    0.0001
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0362             nan     0.1000    0.0058
##      2        0.0306             nan     0.1000    0.0040
##      3        0.0257             nan     0.1000    0.0056
##      4        0.0237             nan     0.1000    0.0023
##      5        0.0212             nan     0.1000    0.0022
##      6        0.0186             nan     0.1000    0.0021
##      7        0.0165             nan     0.1000    0.0020
##      8        0.0145             nan     0.1000    0.0011
##      9        0.0126             nan     0.1000    0.0015
##     10        0.0117             nan     0.1000    0.0005
##     20        0.0037             nan     0.1000    0.0001
##     40        0.0008             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0041
##      2        0.0330             nan     0.1000    0.0040
##      3        0.0281             nan     0.1000    0.0042
##      4        0.0249             nan     0.1000    0.0028
##      5        0.0233             nan     0.1000    0.0014
##      6        0.0217             nan     0.1000   -0.0001
##      7        0.0202             nan     0.1000   -0.0000
##      8        0.0181             nan     0.1000    0.0007
##      9        0.0164             nan     0.1000    0.0010
##     10        0.0149             nan     0.1000    0.0010
##     20        0.0051             nan     0.1000    0.0003
##     40        0.0017             nan     0.1000    0.0001
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.1000    0.0055
##      2        0.0320             nan     0.1000    0.0045
##      3        0.0295             nan     0.1000    0.0017
##      4        0.0280             nan     0.1000   -0.0004
##      5        0.0267             nan     0.1000    0.0015
##      6        0.0244             nan     0.1000    0.0013
##      7        0.0224             nan     0.1000    0.0025
##      8        0.0210             nan     0.1000    0.0010
##      9        0.0184             nan     0.1000    0.0019
##     10        0.0163             nan     0.1000    0.0011
##     20        0.0083             nan     0.1000    0.0004
##     40        0.0044             nan     0.1000   -0.0001
##     60        0.0017             nan     0.1000   -0.0001
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.1000    0.0016
##      2        0.0350             nan     0.1000    0.0018
##      3        0.0295             nan     0.1000    0.0040
##      4        0.0267             nan     0.1000    0.0030
##      5        0.0229             nan     0.1000    0.0015
##      6        0.0188             nan     0.1000    0.0033
##      7        0.0156             nan     0.1000    0.0023
##      8        0.0135             nan     0.1000    0.0007
##      9        0.0121             nan     0.1000    0.0010
##     10        0.0105             nan     0.1000    0.0007
##     20        0.0033             nan     0.1000    0.0003
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0356             nan     0.1000    0.0040
##      2        0.0296             nan     0.1000    0.0032
##      3        0.0255             nan     0.1000    0.0029
##      4        0.0231             nan     0.1000    0.0021
##      5        0.0204             nan     0.1000    0.0028
##      6        0.0179             nan     0.1000    0.0011
##      7        0.0160             nan     0.1000    0.0016
##      8        0.0141             nan     0.1000    0.0014
##      9        0.0132             nan     0.1000    0.0007
##     10        0.0117             nan     0.1000    0.0008
##     20        0.0035             nan     0.1000    0.0002
##     40        0.0012             nan     0.1000    0.0000
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0030
##      2        0.0323             nan     0.1000    0.0021
##      3        0.0288             nan     0.1000    0.0038
##      4        0.0264             nan     0.1000    0.0014
##      5        0.0236             nan     0.1000    0.0006
##      6        0.0219             nan     0.1000   -0.0004
##      7        0.0214             nan     0.1000   -0.0008
##      8        0.0194             nan     0.1000    0.0024
##      9        0.0171             nan     0.1000    0.0021
##     10        0.0152             nan     0.1000    0.0016
##     20        0.0070             nan     0.1000    0.0006
##     40        0.0025             nan     0.1000    0.0000
##     60        0.0010             nan     0.1000    0.0000
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0427             nan     0.0100    0.0001
##      2        0.0421             nan     0.0100    0.0004
##      3        0.0415             nan     0.0100    0.0004
##      4        0.0411             nan     0.0100    0.0000
##      5        0.0406             nan     0.0100    0.0006
##      6        0.0399             nan     0.0100    0.0001
##      7        0.0395             nan     0.0100    0.0003
##      8        0.0391             nan     0.0100    0.0002
##      9        0.0386             nan     0.0100    0.0002
##     10        0.0382             nan     0.0100    0.0003
##     20        0.0343             nan     0.0100    0.0002
##     40        0.0278             nan     0.0100    0.0000
##     60        0.0228             nan     0.0100    0.0002
##     80        0.0187             nan     0.0100    0.0001
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0127             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0000
##    160        0.0090             nan     0.0100    0.0000
##    180        0.0075             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0001
## 
## - Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0006
##      2        0.0417             nan     0.0100    0.0005
##      3        0.0414             nan     0.0100    0.0001
##      4        0.0409             nan     0.0100    0.0005
##      5        0.0403             nan     0.0100    0.0002
##      6        0.0398             nan     0.0100    0.0004
##      7        0.0391             nan     0.0100    0.0005
##      8        0.0385             nan     0.0100    0.0005
##      9        0.0381             nan     0.0100    0.0004
##     10        0.0376             nan     0.0100    0.0004
##     20        0.0335             nan     0.0100    0.0001
##     40        0.0268             nan     0.0100    0.0001
##     60        0.0217             nan     0.0100    0.0002
##     80        0.0178             nan     0.0100    0.0002
##    100        0.0147             nan     0.0100    0.0001
##    120        0.0126             nan     0.0100    0.0000
##    140        0.0107             nan     0.0100    0.0001
##    160        0.0089             nan     0.0100    0.0001
##    180        0.0075             nan     0.0100    0.0000
##    200        0.0064             nan     0.0100    0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0000
##      2        0.0421             nan     0.0100    0.0005
##      3        0.0416             nan     0.0100    0.0006
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0406             nan     0.0100    0.0003
##      6        0.0401             nan     0.0100    0.0006
##      7        0.0395             nan     0.0100    0.0004
##      8        0.0392             nan     0.0100    0.0001
##      9        0.0386             nan     0.0100    0.0005
##     10        0.0382             nan     0.0100    0.0003
##     20        0.0341             nan     0.0100    0.0004
##     40        0.0273             nan     0.0100    0.0002
##     60        0.0222             nan     0.0100    0.0001
##     80        0.0182             nan     0.0100    0.0000
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0130             nan     0.0100    0.0001
##    140        0.0112             nan     0.0100    0.0001
##    160        0.0097             nan     0.0100    0.0001
##    180        0.0086             nan     0.0100    0.0000
##    200        0.0077             nan     0.0100    0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0422             nan     0.0100    0.0005
##      2        0.0415             nan     0.0100    0.0007
##      3        0.0407             nan     0.0100    0.0006
##      4        0.0402             nan     0.0100    0.0002
##      5        0.0397             nan     0.0100    0.0002
##      6        0.0390             nan     0.0100    0.0008
##      7        0.0383             nan     0.0100    0.0005
##      8        0.0379             nan     0.0100    0.0003
##      9        0.0371             nan     0.0100    0.0007
##     10        0.0366             nan     0.0100    0.0002
##     20        0.0316             nan     0.0100    0.0003
##     40        0.0238             nan     0.0100    0.0004
##     60        0.0182             nan     0.0100   -0.0000
##     80        0.0142             nan     0.0100    0.0002
##    100        0.0113             nan     0.0100    0.0000
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0000
##    160        0.0056             nan     0.0100    0.0000
##    180        0.0044             nan     0.0100    0.0001
##    200        0.0037             nan     0.0100   -0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0003
##      2        0.0417             nan     0.0100    0.0007
##      3        0.0411             nan     0.0100    0.0004
##      4        0.0405             nan     0.0100    0.0003
##      5        0.0400             nan     0.0100    0.0004
##      6        0.0396             nan     0.0100    0.0004
##      7        0.0390             nan     0.0100    0.0004
##      8        0.0384             nan     0.0100    0.0002
##      9        0.0379             nan     0.0100    0.0004
##     10        0.0377             nan     0.0100    0.0001
##     20        0.0329             nan     0.0100    0.0005
##     40        0.0251             nan     0.0100    0.0002
##     60        0.0199             nan     0.0100   -0.0000
##     80        0.0154             nan     0.0100    0.0001
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0081             nan     0.0100   -0.0000
##    160        0.0065             nan     0.0100    0.0000
##    180        0.0053             nan     0.0100    0.0000
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0006
##      2        0.0420             nan     0.0100    0.0002
##      3        0.0414             nan     0.0100    0.0005
##      4        0.0409             nan     0.0100    0.0002
##      5        0.0405             nan     0.0100    0.0003
##      6        0.0399             nan     0.0100    0.0006
##      7        0.0397             nan     0.0100    0.0001
##      8        0.0393             nan     0.0100    0.0002
##      9        0.0387             nan     0.0100    0.0005
##     10        0.0383             nan     0.0100    0.0005
##     20        0.0339             nan     0.0100    0.0003
##     40        0.0272             nan     0.0100    0.0001
##     60        0.0220             nan     0.0100    0.0002
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0150             nan     0.0100    0.0001
##    120        0.0127             nan     0.0100    0.0000
##    140        0.0110             nan     0.0100    0.0000
##    160        0.0098             nan     0.0100    0.0000
##    180        0.0086             nan     0.0100    0.0000
##    200        0.0076             nan     0.0100   -0.0001
## 
## - Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0422             nan     0.0100    0.0005
##      2        0.0416             nan     0.0100    0.0005
##      3        0.0412             nan     0.0100    0.0005
##      4        0.0406             nan     0.0100    0.0002
##      5        0.0399             nan     0.0100    0.0006
##      6        0.0394             nan     0.0100    0.0003
##      7        0.0388             nan     0.0100    0.0004
##      8        0.0383             nan     0.0100    0.0003
##      9        0.0376             nan     0.0100    0.0005
##     10        0.0372             nan     0.0100    0.0001
##     20        0.0319             nan     0.0100    0.0002
##     40        0.0242             nan     0.0100   -0.0001
##     60        0.0184             nan     0.0100    0.0002
##     80        0.0140             nan     0.0100    0.0002
##    100        0.0109             nan     0.0100    0.0001
##    120        0.0084             nan     0.0100    0.0001
##    140        0.0067             nan     0.0100   -0.0000
##    160        0.0052             nan     0.0100    0.0000
##    180        0.0041             nan     0.0100    0.0000
##    200        0.0032             nan     0.0100    0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0005
##      2        0.0417             nan     0.0100    0.0005
##      3        0.0412             nan     0.0100    0.0006
##      4        0.0407             nan     0.0100    0.0001
##      5        0.0401             nan     0.0100    0.0005
##      6        0.0395             nan     0.0100    0.0004
##      7        0.0390             nan     0.0100    0.0004
##      8        0.0386             nan     0.0100   -0.0001
##      9        0.0382             nan     0.0100    0.0005
##     10        0.0379             nan     0.0100    0.0002
##     20        0.0337             nan     0.0100    0.0004
##     40        0.0256             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0000
##     80        0.0150             nan     0.0100    0.0002
##    100        0.0118             nan     0.0100    0.0001
##    120        0.0091             nan     0.0100    0.0001
##    140        0.0073             nan     0.0100   -0.0000
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100   -0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0002
##      2        0.0419             nan     0.0100    0.0004
##      3        0.0413             nan     0.0100    0.0006
##      4        0.0407             nan     0.0100    0.0005
##      5        0.0403             nan     0.0100    0.0003
##      6        0.0399             nan     0.0100    0.0001
##      7        0.0394             nan     0.0100    0.0002
##      8        0.0388             nan     0.0100    0.0004
##      9        0.0384             nan     0.0100    0.0005
##     10        0.0379             nan     0.0100    0.0005
##     20        0.0337             nan     0.0100    0.0004
##     40        0.0271             nan     0.0100    0.0003
##     60        0.0220             nan     0.0100    0.0002
##     80        0.0186             nan     0.0100    0.0002
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0131             nan     0.0100    0.0001
##    140        0.0115             nan     0.0100   -0.0000
##    160        0.0100             nan     0.0100   -0.0000
##    180        0.0088             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100   -0.0000
## 
## - Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0005
##      2        0.0378             nan     0.0500    0.0025
##      3        0.0353             nan     0.0500    0.0017
##      4        0.0335             nan     0.0500    0.0019
##      5        0.0314             nan     0.0500    0.0017
##      6        0.0298             nan     0.0500    0.0002
##      7        0.0277             nan     0.0500    0.0022
##      8        0.0262             nan     0.0500    0.0006
##      9        0.0244             nan     0.0500    0.0010
##     10        0.0229             nan     0.0500    0.0014
##     20        0.0135             nan     0.0500    0.0005
##     40        0.0055             nan     0.0500    0.0000
##     60        0.0026             nan     0.0500    0.0000
##     80        0.0014             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.0500   -0.0005
##      2        0.0388             nan     0.0500    0.0021
##      3        0.0366             nan     0.0500    0.0016
##      4        0.0340             nan     0.0500    0.0018
##      5        0.0319             nan     0.0500    0.0018
##      6        0.0296             nan     0.0500    0.0019
##      7        0.0275             nan     0.0500    0.0014
##      8        0.0266             nan     0.0500   -0.0007
##      9        0.0252             nan     0.0500    0.0006
##     10        0.0240             nan     0.0500    0.0007
##     20        0.0143             nan     0.0500    0.0008
##     40        0.0057             nan     0.0500    0.0002
##     60        0.0027             nan     0.0500   -0.0000
##     80        0.0017             nan     0.0500   -0.0001
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0029
##      2        0.0383             nan     0.0500    0.0002
##      3        0.0358             nan     0.0500    0.0017
##      4        0.0334             nan     0.0500    0.0020
##      5        0.0312             nan     0.0500    0.0020
##      6        0.0293             nan     0.0500    0.0017
##      7        0.0279             nan     0.0500    0.0016
##      8        0.0268             nan     0.0500    0.0011
##      9        0.0252             nan     0.0500    0.0014
##     10        0.0244             nan     0.0500    0.0003
##     20        0.0150             nan     0.0500    0.0007
##     40        0.0073             nan     0.0500    0.0001
##     60        0.0045             nan     0.0500    0.0000
##     80        0.0026             nan     0.0500    0.0000
##    100        0.0018             nan     0.0500   -0.0001
##    120        0.0012             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0029
##      2        0.0367             nan     0.0500    0.0029
##      3        0.0351             nan     0.0500    0.0003
##      4        0.0330             nan     0.0500    0.0018
##      5        0.0306             nan     0.0500    0.0015
##      6        0.0291             nan     0.0500    0.0003
##      7        0.0264             nan     0.0500    0.0032
##      8        0.0247             nan     0.0500    0.0013
##      9        0.0226             nan     0.0500    0.0015
##     10        0.0206             nan     0.0500    0.0025
##     20        0.0108             nan     0.0500    0.0003
##     40        0.0038             nan     0.0500   -0.0001
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0400             nan     0.0500    0.0023
##      2        0.0371             nan     0.0500    0.0025
##      3        0.0342             nan     0.0500    0.0020
##      4        0.0324             nan     0.0500    0.0017
##      5        0.0295             nan     0.0500    0.0026
##      6        0.0275             nan     0.0500    0.0014
##      7        0.0258             nan     0.0500    0.0014
##      8        0.0240             nan     0.0500    0.0018
##      9        0.0226             nan     0.0500    0.0011
##     10        0.0219             nan     0.0500    0.0001
##     20        0.0123             nan     0.0500   -0.0005
##     40        0.0041             nan     0.0500    0.0002
##     60        0.0018             nan     0.0500    0.0001
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.0500    0.0028
##      2        0.0372             nan     0.0500    0.0017
##      3        0.0340             nan     0.0500    0.0021
##      4        0.0322             nan     0.0500    0.0020
##      5        0.0300             nan     0.0500    0.0016
##      6        0.0284             nan     0.0500    0.0010
##      7        0.0270             nan     0.0500    0.0014
##      8        0.0258             nan     0.0500    0.0004
##      9        0.0246             nan     0.0500    0.0004
##     10        0.0232             nan     0.0500    0.0013
##     20        0.0161             nan     0.0500    0.0007
##     40        0.0078             nan     0.0500    0.0001
##     60        0.0052             nan     0.0500    0.0001
##     80        0.0034             nan     0.0500    0.0000
##    100        0.0020             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0009             nan     0.0500    0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.0500    0.0019
##      2        0.0364             nan     0.0500    0.0021
##      3        0.0338             nan     0.0500    0.0022
##      4        0.0306             nan     0.0500    0.0029
##      5        0.0282             nan     0.0500    0.0015
##      6        0.0259             nan     0.0500    0.0011
##      7        0.0249             nan     0.0500    0.0011
##      8        0.0239             nan     0.0500    0.0004
##      9        0.0222             nan     0.0500    0.0006
##     10        0.0208             nan     0.0500    0.0014
##     20        0.0105             nan     0.0500    0.0007
##     40        0.0031             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0030
##      2        0.0382             nan     0.0500    0.0015
##      3        0.0354             nan     0.0500    0.0028
##      4        0.0328             nan     0.0500    0.0014
##      5        0.0301             nan     0.0500    0.0025
##      6        0.0274             nan     0.0500    0.0022
##      7        0.0254             nan     0.0500    0.0016
##      8        0.0241             nan     0.0500    0.0011
##      9        0.0226             nan     0.0500    0.0005
##     10        0.0213             nan     0.0500    0.0016
##     20        0.0103             nan     0.0500    0.0005
##     40        0.0033             nan     0.0500    0.0001
##     60        0.0015             nan     0.0500   -0.0000
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0008
##      2        0.0388             nan     0.0500    0.0020
##      3        0.0365             nan     0.0500    0.0017
##      4        0.0341             nan     0.0500    0.0013
##      5        0.0325             nan     0.0500    0.0014
##      6        0.0321             nan     0.0500   -0.0003
##      7        0.0302             nan     0.0500    0.0019
##      8        0.0281             nan     0.0500    0.0019
##      9        0.0261             nan     0.0500    0.0011
##     10        0.0245             nan     0.0500    0.0013
##     20        0.0157             nan     0.0500    0.0002
##     40        0.0079             nan     0.0500    0.0001
##     60        0.0044             nan     0.0500    0.0000
##     80        0.0031             nan     0.0500    0.0000
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0058
##      2        0.0338             nan     0.1000    0.0028
##      3        0.0285             nan     0.1000    0.0041
##      4        0.0246             nan     0.1000    0.0037
##      5        0.0230             nan     0.1000    0.0016
##      6        0.0202             nan     0.1000    0.0024
##      7        0.0179             nan     0.1000    0.0008
##      8        0.0157             nan     0.1000    0.0025
##      9        0.0154             nan     0.1000   -0.0005
##     10        0.0138             nan     0.1000    0.0009
##     20        0.0055             nan     0.1000    0.0002
##     40        0.0014             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.1000    0.0054
##      2        0.0334             nan     0.1000    0.0018
##      3        0.0312             nan     0.1000    0.0023
##      4        0.0298             nan     0.1000   -0.0011
##      5        0.0275             nan     0.1000    0.0016
##      6        0.0247             nan     0.1000    0.0026
##      7        0.0220             nan     0.1000    0.0003
##      8        0.0199             nan     0.1000    0.0009
##      9        0.0179             nan     0.1000    0.0014
##     10        0.0170             nan     0.1000    0.0008
##     20        0.0079             nan     0.1000    0.0003
##     40        0.0025             nan     0.1000   -0.0001
##     60        0.0010             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0051
##      2        0.0346             nan     0.1000    0.0021
##      3        0.0308             nan     0.1000    0.0041
##      4        0.0273             nan     0.1000    0.0034
##      5        0.0253             nan     0.1000    0.0013
##      6        0.0222             nan     0.1000    0.0024
##      7        0.0195             nan     0.1000    0.0014
##      8        0.0177             nan     0.1000    0.0007
##      9        0.0170             nan     0.1000   -0.0002
##     10        0.0157             nan     0.1000    0.0010
##     20        0.0090             nan     0.1000   -0.0005
##     40        0.0038             nan     0.1000   -0.0001
##     60        0.0017             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.1000    0.0043
##      2        0.0308             nan     0.1000    0.0056
##      3        0.0251             nan     0.1000    0.0031
##      4        0.0215             nan     0.1000    0.0017
##      5        0.0198             nan     0.1000    0.0007
##      6        0.0185             nan     0.1000   -0.0003
##      7        0.0159             nan     0.1000    0.0012
##      8        0.0133             nan     0.1000    0.0012
##      9        0.0113             nan     0.1000    0.0014
##     10        0.0103             nan     0.1000    0.0005
##     20        0.0031             nan     0.1000   -0.0000
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.1000    0.0032
##      2        0.0331             nan     0.1000    0.0043
##      3        0.0289             nan     0.1000    0.0029
##      4        0.0253             nan     0.1000    0.0033
##      5        0.0224             nan     0.1000    0.0029
##      6        0.0190             nan     0.1000    0.0027
##      7        0.0169             nan     0.1000    0.0021
##      8        0.0141             nan     0.1000    0.0013
##      9        0.0125             nan     0.1000    0.0019
##     10        0.0115             nan     0.1000    0.0007
##     20        0.0037             nan     0.1000    0.0000
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.1000    0.0016
##      2        0.0345             nan     0.1000    0.0032
##      3        0.0312             nan     0.1000    0.0043
##      4        0.0289             nan     0.1000   -0.0000
##      5        0.0263             nan     0.1000    0.0015
##      6        0.0221             nan     0.1000    0.0028
##      7        0.0199             nan     0.1000    0.0014
##      8        0.0171             nan     0.1000    0.0017
##      9        0.0155             nan     0.1000    0.0008
##     10        0.0141             nan     0.1000    0.0011
##     20        0.0075             nan     0.1000    0.0005
##     40        0.0028             nan     0.1000    0.0001
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0349             nan     0.1000    0.0055
##      2        0.0293             nan     0.1000    0.0067
##      3        0.0251             nan     0.1000    0.0029
##      4        0.0213             nan     0.1000    0.0042
##      5        0.0200             nan     0.1000    0.0003
##      6        0.0173             nan     0.1000    0.0026
##      7        0.0148             nan     0.1000    0.0024
##      8        0.0132             nan     0.1000    0.0007
##      9        0.0115             nan     0.1000    0.0006
##     10        0.0093             nan     0.1000    0.0013
##     20        0.0028             nan     0.1000    0.0003
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0055
##      2        0.0325             nan     0.1000    0.0028
##      3        0.0298             nan     0.1000    0.0022
##      4        0.0252             nan     0.1000    0.0036
##      5        0.0242             nan     0.1000    0.0000
##      6        0.0207             nan     0.1000    0.0026
##      7        0.0182             nan     0.1000    0.0013
##      8        0.0165             nan     0.1000    0.0012
##      9        0.0147             nan     0.1000    0.0004
##     10        0.0143             nan     0.1000   -0.0010
##     20        0.0056             nan     0.1000    0.0003
##     40        0.0011             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.1000    0.0053
##      2        0.0331             nan     0.1000    0.0018
##      3        0.0293             nan     0.1000    0.0038
##      4        0.0265             nan     0.1000    0.0030
##      5        0.0235             nan     0.1000    0.0018
##      6        0.0206             nan     0.1000    0.0025
##      7        0.0185             nan     0.1000   -0.0006
##      8        0.0160             nan     0.1000    0.0013
##      9        0.0143             nan     0.1000    0.0011
##     10        0.0137             nan     0.1000   -0.0011
##     20        0.0082             nan     0.1000    0.0002
##     40        0.0031             nan     0.1000   -0.0001
##     60        0.0016             nan     0.1000    0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0004
##      2        0.0434             nan     0.0100    0.0003
##      3        0.0428             nan     0.0100    0.0003
##      4        0.0423             nan     0.0100    0.0005
##      5        0.0418             nan     0.0100    0.0002
##      6        0.0413             nan     0.0100    0.0002
##      7        0.0408             nan     0.0100    0.0006
##      8        0.0405             nan     0.0100    0.0001
##      9        0.0400             nan     0.0100    0.0003
##     10        0.0394             nan     0.0100    0.0006
##     20        0.0347             nan     0.0100    0.0001
##     40        0.0280             nan     0.0100   -0.0000
##     60        0.0223             nan     0.0100    0.0001
##     80        0.0179             nan     0.0100    0.0001
##    100        0.0147             nan     0.0100    0.0001
##    120        0.0121             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0000
##    160        0.0084             nan     0.0100    0.0000
##    180        0.0071             nan     0.0100    0.0000
##    200        0.0061             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0433             nan     0.0100    0.0006
##      3        0.0427             nan     0.0100    0.0006
##      4        0.0420             nan     0.0100    0.0003
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0403             nan     0.0100    0.0005
##      8        0.0398             nan     0.0100    0.0005
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0389             nan     0.0100    0.0005
##     20        0.0346             nan     0.0100    0.0004
##     40        0.0275             nan     0.0100    0.0002
##     60        0.0224             nan     0.0100    0.0003
##     80        0.0186             nan     0.0100   -0.0000
##    100        0.0154             nan     0.0100    0.0000
##    120        0.0125             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0000
##    160        0.0089             nan     0.0100    0.0001
##    180        0.0076             nan     0.0100    0.0000
##    200        0.0064             nan     0.0100   -0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0440             nan     0.0100    0.0004
##      2        0.0435             nan     0.0100    0.0002
##      3        0.0428             nan     0.0100    0.0006
##      4        0.0423             nan     0.0100    0.0005
##      5        0.0417             nan     0.0100    0.0006
##      6        0.0410             nan     0.0100    0.0006
##      7        0.0404             nan     0.0100    0.0006
##      8        0.0400             nan     0.0100    0.0002
##      9        0.0396             nan     0.0100    0.0004
##     10        0.0390             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0002
##     40        0.0275             nan     0.0100    0.0003
##     60        0.0222             nan     0.0100    0.0003
##     80        0.0186             nan     0.0100    0.0002
##    100        0.0158             nan     0.0100   -0.0001
##    120        0.0136             nan     0.0100    0.0001
##    140        0.0119             nan     0.0100    0.0000
##    160        0.0104             nan     0.0100    0.0001
##    180        0.0092             nan     0.0100   -0.0000
##    200        0.0081             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0004
##      2        0.0429             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0006
##      4        0.0414             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0007
##      6        0.0403             nan     0.0100    0.0003
##      7        0.0399             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0002
##      9        0.0392             nan     0.0100    0.0002
##     10        0.0389             nan     0.0100   -0.0002
##     20        0.0341             nan     0.0100    0.0004
##     40        0.0253             nan     0.0100    0.0002
##     60        0.0193             nan     0.0100    0.0000
##     80        0.0147             nan     0.0100    0.0002
##    100        0.0116             nan     0.0100   -0.0000
##    120        0.0092             nan     0.0100    0.0000
##    140        0.0073             nan     0.0100    0.0001
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100    0.0000
##    200        0.0037             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0007
##      2        0.0431             nan     0.0100    0.0004
##      3        0.0424             nan     0.0100    0.0003
##      4        0.0418             nan     0.0100    0.0006
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0412             nan     0.0100   -0.0001
##      7        0.0407             nan     0.0100    0.0006
##      8        0.0400             nan     0.0100    0.0005
##      9        0.0395             nan     0.0100    0.0005
##     10        0.0389             nan     0.0100    0.0006
##     20        0.0336             nan     0.0100    0.0001
##     40        0.0252             nan     0.0100    0.0001
##     60        0.0193             nan     0.0100    0.0002
##     80        0.0144             nan     0.0100    0.0002
##    100        0.0113             nan     0.0100    0.0001
##    120        0.0092             nan     0.0100    0.0001
##    140        0.0076             nan     0.0100    0.0000
##    160        0.0062             nan     0.0100    0.0001
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100    0.0005
##      2        0.0434             nan     0.0100    0.0006
##      3        0.0428             nan     0.0100    0.0004
##      4        0.0421             nan     0.0100    0.0006
##      5        0.0415             nan     0.0100    0.0004
##      6        0.0408             nan     0.0100    0.0006
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0398             nan     0.0100    0.0003
##      9        0.0394             nan     0.0100    0.0003
##     10        0.0387             nan     0.0100    0.0006
##     20        0.0340             nan     0.0100    0.0004
##     40        0.0278             nan     0.0100    0.0001
##     60        0.0230             nan     0.0100    0.0003
##     80        0.0196             nan     0.0100    0.0001
##    100        0.0166             nan     0.0100    0.0001
##    120        0.0142             nan     0.0100   -0.0000
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0105             nan     0.0100    0.0000
##    180        0.0093             nan     0.0100    0.0001
##    200        0.0083             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0010
##      2        0.0428             nan     0.0100    0.0006
##      3        0.0424             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100    0.0009
##      5        0.0412             nan     0.0100    0.0003
##      6        0.0404             nan     0.0100    0.0007
##      7        0.0402             nan     0.0100   -0.0001
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0390             nan     0.0100    0.0003
##     10        0.0385             nan     0.0100    0.0005
##     20        0.0328             nan     0.0100    0.0004
##     40        0.0243             nan     0.0100    0.0001
##     60        0.0184             nan     0.0100    0.0002
##     80        0.0140             nan     0.0100    0.0001
##    100        0.0107             nan     0.0100    0.0001
##    120        0.0085             nan     0.0100    0.0000
##    140        0.0064             nan     0.0100    0.0001
##    160        0.0050             nan     0.0100   -0.0000
##    180        0.0039             nan     0.0100    0.0000
##    200        0.0031             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0007
##      2        0.0428             nan     0.0100    0.0005
##      3        0.0420             nan     0.0100    0.0007
##      4        0.0413             nan     0.0100    0.0007
##      5        0.0406             nan     0.0100    0.0006
##      6        0.0401             nan     0.0100    0.0003
##      7        0.0396             nan     0.0100    0.0005
##      8        0.0390             nan     0.0100    0.0001
##      9        0.0385             nan     0.0100    0.0005
##     10        0.0381             nan     0.0100    0.0003
##     20        0.0335             nan     0.0100    0.0006
##     40        0.0257             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0003
##     80        0.0151             nan     0.0100    0.0002
##    100        0.0119             nan     0.0100    0.0001
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0075             nan     0.0100    0.0001
##    160        0.0060             nan     0.0100    0.0001
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100   -0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0431             nan     0.0100    0.0005
##      3        0.0425             nan     0.0100    0.0004
##      4        0.0422             nan     0.0100    0.0003
##      5        0.0419             nan     0.0100    0.0000
##      6        0.0413             nan     0.0100    0.0005
##      7        0.0409             nan     0.0100    0.0001
##      8        0.0403             nan     0.0100    0.0006
##      9        0.0397             nan     0.0100    0.0004
##     10        0.0392             nan     0.0100    0.0005
##     20        0.0342             nan     0.0100    0.0005
##     40        0.0269             nan     0.0100    0.0002
##     60        0.0218             nan     0.0100    0.0002
##     80        0.0184             nan     0.0100    0.0001
##    100        0.0154             nan     0.0100    0.0000
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0115             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100    0.0000
##    180        0.0092             nan     0.0100   -0.0001
##    200        0.0081             nan     0.0100    0.0000
## 
## - Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0028
##      2        0.0388             nan     0.0500    0.0028
##      3        0.0365             nan     0.0500    0.0027
##      4        0.0340             nan     0.0500    0.0016
##      5        0.0317             nan     0.0500    0.0019
##      6        0.0300             nan     0.0500    0.0019
##      7        0.0284             nan     0.0500    0.0007
##      8        0.0266             nan     0.0500    0.0013
##      9        0.0252             nan     0.0500    0.0011
##     10        0.0237             nan     0.0500    0.0016
##     20        0.0135             nan     0.0500    0.0005
##     40        0.0060             nan     0.0500    0.0002
##     60        0.0028             nan     0.0500    0.0000
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0032
##      2        0.0390             nan     0.0500    0.0032
##      3        0.0370             nan     0.0500    0.0016
##      4        0.0351             nan     0.0500    0.0013
##      5        0.0335             nan     0.0500    0.0019
##      6        0.0314             nan     0.0500    0.0010
##      7        0.0299             nan     0.0500    0.0018
##      8        0.0285             nan     0.0500    0.0001
##      9        0.0271             nan     0.0500    0.0014
##     10        0.0256             nan     0.0500    0.0014
##     20        0.0150             nan     0.0500    0.0008
##     40        0.0063             nan     0.0500    0.0002
##     60        0.0031             nan     0.0500    0.0001
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0018
##      2        0.0381             nan     0.0500    0.0020
##      3        0.0361             nan     0.0500    0.0009
##      4        0.0341             nan     0.0500    0.0021
##      5        0.0319             nan     0.0500    0.0021
##      6        0.0300             nan     0.0500    0.0014
##      7        0.0277             nan     0.0500    0.0018
##      8        0.0266             nan     0.0500    0.0009
##      9        0.0249             nan     0.0500    0.0013
##     10        0.0240             nan     0.0500    0.0012
##     20        0.0161             nan     0.0500    0.0003
##     40        0.0075             nan     0.0500    0.0002
##     60        0.0051             nan     0.0500    0.0001
##     80        0.0032             nan     0.0500   -0.0001
##    100        0.0022             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0500    0.0011
##      2        0.0384             nan     0.0500    0.0037
##      3        0.0358             nan     0.0500    0.0027
##      4        0.0333             nan     0.0500    0.0026
##      5        0.0304             nan     0.0500    0.0025
##      6        0.0279             nan     0.0500    0.0020
##      7        0.0269             nan     0.0500    0.0005
##      8        0.0258             nan     0.0500   -0.0000
##      9        0.0239             nan     0.0500    0.0022
##     10        0.0219             nan     0.0500    0.0013
##     20        0.0114             nan     0.0500    0.0007
##     40        0.0034             nan     0.0500    0.0001
##     60        0.0014             nan     0.0500    0.0001
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0422             nan     0.0500    0.0020
##      2        0.0391             nan     0.0500    0.0023
##      3        0.0366             nan     0.0500    0.0020
##      4        0.0339             nan     0.0500    0.0025
##      5        0.0311             nan     0.0500    0.0011
##      6        0.0299             nan     0.0500    0.0009
##      7        0.0278             nan     0.0500    0.0022
##      8        0.0258             nan     0.0500    0.0009
##      9        0.0237             nan     0.0500    0.0012
##     10        0.0228             nan     0.0500   -0.0002
##     20        0.0116             nan     0.0500    0.0005
##     40        0.0043             nan     0.0500   -0.0001
##     60        0.0019             nan     0.0500    0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0025
##      2        0.0383             nan     0.0500    0.0028
##      3        0.0368             nan     0.0500    0.0008
##      4        0.0345             nan     0.0500    0.0019
##      5        0.0329             nan     0.0500    0.0015
##      6        0.0312             nan     0.0500    0.0011
##      7        0.0297             nan     0.0500    0.0018
##      8        0.0280             nan     0.0500    0.0015
##      9        0.0267             nan     0.0500    0.0008
##     10        0.0252             nan     0.0500    0.0008
##     20        0.0159             nan     0.0500    0.0007
##     40        0.0088             nan     0.0500    0.0000
##     60        0.0048             nan     0.0500    0.0002
##     80        0.0029             nan     0.0500    0.0000
##    100        0.0020             nan     0.0500   -0.0000
##    120        0.0013             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0027
##      2        0.0366             nan     0.0500    0.0032
##      3        0.0334             nan     0.0500    0.0020
##      4        0.0309             nan     0.0500    0.0019
##      5        0.0292             nan     0.0500    0.0012
##      6        0.0271             nan     0.0500    0.0016
##      7        0.0248             nan     0.0500    0.0010
##      8        0.0230             nan     0.0500    0.0018
##      9        0.0209             nan     0.0500    0.0015
##     10        0.0196             nan     0.0500    0.0009
##     20        0.0098             nan     0.0500    0.0001
##     40        0.0026             nan     0.0500   -0.0001
##     60        0.0009             nan     0.0500    0.0000
##     80        0.0003             nan     0.0500   -0.0000
##    100        0.0001             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0018
##      2        0.0383             nan     0.0500    0.0038
##      3        0.0371             nan     0.0500    0.0012
##      4        0.0348             nan     0.0500    0.0018
##      5        0.0323             nan     0.0500    0.0015
##      6        0.0299             nan     0.0500    0.0013
##      7        0.0274             nan     0.0500    0.0021
##      8        0.0245             nan     0.0500    0.0022
##      9        0.0219             nan     0.0500    0.0017
##     10        0.0207             nan     0.0500    0.0009
##     20        0.0118             nan     0.0500    0.0004
##     40        0.0046             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.0500    0.0018
##      2        0.0399             nan     0.0500    0.0019
##      3        0.0373             nan     0.0500    0.0026
##      4        0.0345             nan     0.0500    0.0025
##      5        0.0326             nan     0.0500    0.0012
##      6        0.0306             nan     0.0500    0.0018
##      7        0.0282             nan     0.0500    0.0018
##      8        0.0273             nan     0.0500    0.0009
##      9        0.0262             nan     0.0500    0.0009
##     10        0.0251             nan     0.0500    0.0009
##     20        0.0159             nan     0.0500    0.0002
##     40        0.0085             nan     0.0500    0.0001
##     60        0.0052             nan     0.0500   -0.0001
##     80        0.0035             nan     0.0500   -0.0001
##    100        0.0025             nan     0.0500   -0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0382             nan     0.1000    0.0062
##      2        0.0330             nan     0.1000    0.0048
##      3        0.0284             nan     0.1000    0.0042
##      4        0.0257             nan     0.1000    0.0030
##      5        0.0233             nan     0.1000   -0.0004
##      6        0.0205             nan     0.1000    0.0024
##      7        0.0188             nan     0.1000    0.0011
##      8        0.0172             nan     0.1000    0.0014
##      9        0.0163             nan     0.1000    0.0011
##     10        0.0137             nan     0.1000    0.0031
##     20        0.0060             nan     0.1000   -0.0004
##     40        0.0019             nan     0.1000    0.0001
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.1000    0.0046
##      2        0.0354             nan     0.1000    0.0040
##      3        0.0307             nan     0.1000    0.0042
##      4        0.0270             nan     0.1000    0.0036
##      5        0.0240             nan     0.1000    0.0010
##      6        0.0219             nan     0.1000    0.0018
##      7        0.0189             nan     0.1000    0.0022
##      8        0.0171             nan     0.1000    0.0005
##      9        0.0151             nan     0.1000    0.0015
##     10        0.0134             nan     0.1000    0.0010
##     20        0.0055             nan     0.1000    0.0003
##     40        0.0017             nan     0.1000    0.0001
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0061
##      2        0.0338             nan     0.1000    0.0040
##      3        0.0296             nan     0.1000    0.0037
##      4        0.0265             nan     0.1000    0.0012
##      5        0.0228             nan     0.1000    0.0030
##      6        0.0204             nan     0.1000    0.0024
##      7        0.0180             nan     0.1000    0.0011
##      8        0.0162             nan     0.1000    0.0010
##      9        0.0147             nan     0.1000    0.0014
##     10        0.0141             nan     0.1000    0.0006
##     20        0.0076             nan     0.1000   -0.0001
##     40        0.0027             nan     0.1000   -0.0000
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.1000    0.0032
##      2        0.0345             nan     0.1000    0.0039
##      3        0.0311             nan     0.1000    0.0024
##      4        0.0255             nan     0.1000    0.0042
##      5        0.0234             nan     0.1000    0.0013
##      6        0.0210             nan     0.1000    0.0008
##      7        0.0175             nan     0.1000    0.0034
##      8        0.0154             nan     0.1000    0.0023
##      9        0.0133             nan     0.1000    0.0017
##     10        0.0118             nan     0.1000    0.0007
##     20        0.0046             nan     0.1000   -0.0008
##     40        0.0010             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0038
##      2        0.0356             nan     0.1000   -0.0002
##      3        0.0310             nan     0.1000    0.0044
##      4        0.0284             nan     0.1000    0.0013
##      5        0.0259             nan     0.1000    0.0018
##      6        0.0246             nan     0.1000    0.0008
##      7        0.0216             nan     0.1000    0.0023
##      8        0.0185             nan     0.1000    0.0009
##      9        0.0166             nan     0.1000    0.0010
##     10        0.0147             nan     0.1000    0.0014
##     20        0.0048             nan     0.1000    0.0003
##     40        0.0013             nan     0.1000    0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.1000    0.0051
##      2        0.0333             nan     0.1000    0.0044
##      3        0.0312             nan     0.1000    0.0009
##      4        0.0282             nan     0.1000    0.0024
##      5        0.0249             nan     0.1000    0.0025
##      6        0.0232             nan     0.1000    0.0013
##      7        0.0202             nan     0.1000    0.0017
##      8        0.0188             nan     0.1000   -0.0007
##      9        0.0171             nan     0.1000    0.0005
##     10        0.0154             nan     0.1000    0.0006
##     20        0.0081             nan     0.1000   -0.0003
##     40        0.0036             nan     0.1000    0.0001
##     60        0.0018             nan     0.1000   -0.0001
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0053
##      2        0.0325             nan     0.1000    0.0062
##      3        0.0263             nan     0.1000    0.0029
##      4        0.0228             nan     0.1000    0.0024
##      5        0.0190             nan     0.1000    0.0034
##      6        0.0151             nan     0.1000    0.0022
##      7        0.0132             nan     0.1000   -0.0006
##      8        0.0122             nan     0.1000   -0.0006
##      9        0.0109             nan     0.1000    0.0009
##     10        0.0095             nan     0.1000    0.0004
##     20        0.0036             nan     0.1000   -0.0001
##     40        0.0008             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.1000    0.0038
##      2        0.0329             nan     0.1000    0.0016
##      3        0.0285             nan     0.1000    0.0039
##      4        0.0251             nan     0.1000    0.0022
##      5        0.0215             nan     0.1000    0.0009
##      6        0.0178             nan     0.1000    0.0027
##      7        0.0160             nan     0.1000    0.0016
##      8        0.0137             nan     0.1000    0.0016
##      9        0.0121             nan     0.1000    0.0013
##     10        0.0107             nan     0.1000    0.0001
##     20        0.0038             nan     0.1000    0.0003
##     40        0.0009             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.1000    0.0025
##      2        0.0353             nan     0.1000    0.0050
##      3        0.0313             nan     0.1000    0.0047
##      4        0.0275             nan     0.1000    0.0019
##      5        0.0242             nan     0.1000    0.0031
##      6        0.0217             nan     0.1000    0.0007
##      7        0.0199             nan     0.1000    0.0020
##      8        0.0180             nan     0.1000    0.0022
##      9        0.0166             nan     0.1000    0.0012
##     10        0.0146             nan     0.1000    0.0010
##     20        0.0071             nan     0.1000    0.0003
##     40        0.0034             nan     0.1000   -0.0000
##     60        0.0015             nan     0.1000    0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0005
##      2        0.0398             nan     0.0100    0.0006
##      3        0.0393             nan     0.0100    0.0005
##      4        0.0388             nan     0.0100    0.0006
##      5        0.0382             nan     0.0100    0.0004
##      6        0.0375             nan     0.0100    0.0006
##      7        0.0371             nan     0.0100    0.0003
##      8        0.0365             nan     0.0100    0.0003
##      9        0.0361             nan     0.0100    0.0003
##     10        0.0359             nan     0.0100    0.0001
##     20        0.0317             nan     0.0100    0.0004
##     40        0.0255             nan     0.0100    0.0003
##     60        0.0204             nan     0.0100   -0.0001
##     80        0.0166             nan     0.0100    0.0001
##    100        0.0135             nan     0.0100    0.0001
##    120        0.0110             nan     0.0100    0.0001
##    140        0.0092             nan     0.0100    0.0001
##    160        0.0075             nan     0.0100    0.0000
##    180        0.0063             nan     0.0100   -0.0000
##    200        0.0053             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0100    0.0001
##      2        0.0400             nan     0.0100    0.0002
##      3        0.0395             nan     0.0100    0.0005
##      4        0.0389             nan     0.0100    0.0004
##      5        0.0384             nan     0.0100    0.0002
##      6        0.0379             nan     0.0100    0.0004
##      7        0.0375             nan     0.0100    0.0003
##      8        0.0371             nan     0.0100    0.0000
##      9        0.0365             nan     0.0100    0.0005
##     10        0.0361             nan     0.0100    0.0004
##     20        0.0323             nan     0.0100    0.0003
##     40        0.0255             nan     0.0100    0.0003
##     60        0.0205             nan     0.0100    0.0002
##     80        0.0165             nan     0.0100    0.0002
##    100        0.0134             nan     0.0100    0.0001
##    120        0.0113             nan     0.0100    0.0000
##    140        0.0094             nan     0.0100    0.0001
##    160        0.0080             nan     0.0100   -0.0000
##    180        0.0067             nan     0.0100    0.0000
##    200        0.0057             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0006
##      2        0.0399             nan     0.0100    0.0003
##      3        0.0393             nan     0.0100    0.0004
##      4        0.0387             nan     0.0100    0.0005
##      5        0.0385             nan     0.0100   -0.0000
##      6        0.0380             nan     0.0100    0.0005
##      7        0.0377             nan     0.0100    0.0002
##      8        0.0373             nan     0.0100    0.0005
##      9        0.0368             nan     0.0100    0.0003
##     10        0.0363             nan     0.0100    0.0004
##     20        0.0320             nan     0.0100    0.0003
##     40        0.0254             nan     0.0100    0.0002
##     60        0.0209             nan     0.0100    0.0001
##     80        0.0171             nan     0.0100    0.0002
##    100        0.0140             nan     0.0100    0.0001
##    120        0.0118             nan     0.0100    0.0000
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0089             nan     0.0100    0.0000
##    180        0.0081             nan     0.0100   -0.0000
##    200        0.0071             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0100    0.0005
##      2        0.0395             nan     0.0100    0.0003
##      3        0.0389             nan     0.0100    0.0006
##      4        0.0384             nan     0.0100    0.0004
##      5        0.0378             nan     0.0100    0.0005
##      6        0.0372             nan     0.0100    0.0004
##      7        0.0366             nan     0.0100    0.0005
##      8        0.0362             nan     0.0100   -0.0000
##      9        0.0356             nan     0.0100    0.0003
##     10        0.0349             nan     0.0100    0.0007
##     20        0.0307             nan     0.0100    0.0002
##     40        0.0231             nan     0.0100    0.0003
##     60        0.0179             nan     0.0100    0.0002
##     80        0.0140             nan     0.0100    0.0000
##    100        0.0109             nan     0.0100    0.0000
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0071             nan     0.0100   -0.0000
##    160        0.0059             nan     0.0100   -0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0100    0.0006
##      2        0.0397             nan     0.0100    0.0004
##      3        0.0390             nan     0.0100    0.0005
##      4        0.0387             nan     0.0100    0.0000
##      5        0.0382             nan     0.0100    0.0002
##      6        0.0379             nan     0.0100    0.0001
##      7        0.0374             nan     0.0100    0.0005
##      8        0.0368             nan     0.0100    0.0005
##      9        0.0364             nan     0.0100    0.0002
##     10        0.0359             nan     0.0100    0.0004
##     20        0.0307             nan     0.0100    0.0004
##     40        0.0239             nan     0.0100    0.0003
##     60        0.0187             nan     0.0100    0.0002
##     80        0.0146             nan     0.0100    0.0002
##    100        0.0115             nan     0.0100    0.0001
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0073             nan     0.0100    0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0004
##      2        0.0398             nan     0.0100    0.0004
##      3        0.0393             nan     0.0100    0.0004
##      4        0.0387             nan     0.0100    0.0004
##      5        0.0383             nan     0.0100    0.0005
##      6        0.0378             nan     0.0100    0.0005
##      7        0.0373             nan     0.0100    0.0005
##      8        0.0369             nan     0.0100    0.0003
##      9        0.0365             nan     0.0100    0.0003
##     10        0.0361             nan     0.0100    0.0003
##     20        0.0324             nan     0.0100    0.0004
##     40        0.0263             nan     0.0100    0.0003
##     60        0.0216             nan     0.0100    0.0000
##     80        0.0175             nan     0.0100    0.0001
##    100        0.0149             nan     0.0100    0.0001
##    120        0.0128             nan     0.0100   -0.0001
##    140        0.0109             nan     0.0100    0.0001
##    160        0.0097             nan     0.0100    0.0000
##    180        0.0086             nan     0.0100   -0.0000
##    200        0.0076             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0100    0.0002
##      2        0.0396             nan     0.0100    0.0003
##      3        0.0393             nan     0.0100    0.0003
##      4        0.0388             nan     0.0100    0.0005
##      5        0.0382             nan     0.0100    0.0005
##      6        0.0376             nan     0.0100    0.0006
##      7        0.0373             nan     0.0100    0.0001
##      8        0.0367             nan     0.0100    0.0005
##      9        0.0361             nan     0.0100    0.0003
##     10        0.0357             nan     0.0100    0.0004
##     20        0.0305             nan     0.0100    0.0005
##     40        0.0226             nan     0.0100    0.0001
##     60        0.0170             nan     0.0100    0.0002
##     80        0.0131             nan     0.0100    0.0001
##    100        0.0099             nan     0.0100    0.0001
##    120        0.0077             nan     0.0100    0.0001
##    140        0.0060             nan     0.0100    0.0000
##    160        0.0047             nan     0.0100    0.0000
##    180        0.0037             nan     0.0100    0.0000
##    200        0.0030             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0100    0.0004
##      2        0.0396             nan     0.0100    0.0006
##      3        0.0389             nan     0.0100    0.0004
##      4        0.0383             nan     0.0100    0.0001
##      5        0.0379             nan     0.0100    0.0001
##      6        0.0375             nan     0.0100    0.0003
##      7        0.0370             nan     0.0100    0.0003
##      8        0.0365             nan     0.0100    0.0006
##      9        0.0360             nan     0.0100    0.0005
##     10        0.0355             nan     0.0100    0.0003
##     20        0.0310             nan     0.0100    0.0004
##     40        0.0239             nan     0.0100    0.0002
##     60        0.0182             nan     0.0100    0.0002
##     80        0.0137             nan     0.0100    0.0001
##    100        0.0109             nan     0.0100    0.0000
##    120        0.0088             nan     0.0100    0.0000
##    140        0.0070             nan     0.0100    0.0000
##    160        0.0056             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100   -0.0000
##    200        0.0038             nan     0.0100   -0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0006
##      2        0.0399             nan     0.0100    0.0004
##      3        0.0392             nan     0.0100    0.0004
##      4        0.0389             nan     0.0100    0.0003
##      5        0.0385             nan     0.0100    0.0004
##      6        0.0379             nan     0.0100    0.0002
##      7        0.0375             nan     0.0100    0.0003
##      8        0.0371             nan     0.0100    0.0003
##      9        0.0367             nan     0.0100    0.0005
##     10        0.0363             nan     0.0100    0.0004
##     20        0.0322             nan     0.0100    0.0004
##     40        0.0257             nan     0.0100    0.0002
##     60        0.0212             nan     0.0100    0.0002
##     80        0.0175             nan     0.0100    0.0000
##    100        0.0147             nan     0.0100    0.0001
##    120        0.0124             nan     0.0100    0.0001
##    140        0.0106             nan     0.0100    0.0001
##    160        0.0092             nan     0.0100    0.0000
##    180        0.0081             nan     0.0100    0.0000
##    200        0.0071             nan     0.0100    0.0000
## 
## - Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.0500    0.0025
##      2        0.0375             nan     0.0500   -0.0009
##      3        0.0354             nan     0.0500    0.0023
##      4        0.0347             nan     0.0500   -0.0001
##      5        0.0328             nan     0.0500    0.0002
##      6        0.0317             nan     0.0500    0.0010
##      7        0.0294             nan     0.0500    0.0021
##      8        0.0280             nan     0.0500    0.0017
##      9        0.0266             nan     0.0500    0.0012
##     10        0.0257             nan     0.0500    0.0006
##     20        0.0156             nan     0.0500    0.0005
##     40        0.0072             nan     0.0500   -0.0005
##     60        0.0037             nan     0.0500   -0.0000
##     80        0.0021             nan     0.0500    0.0000
##    100        0.0013             nan     0.0500    0.0000
##    120        0.0008             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.0500    0.0023
##      2        0.0348             nan     0.0500    0.0024
##      3        0.0320             nan     0.0500    0.0020
##      4        0.0298             nan     0.0500    0.0013
##      5        0.0280             nan     0.0500    0.0016
##      6        0.0262             nan     0.0500    0.0007
##      7        0.0250             nan     0.0500    0.0001
##      8        0.0233             nan     0.0500    0.0013
##      9        0.0219             nan     0.0500    0.0014
##     10        0.0207             nan     0.0500    0.0004
##     20        0.0135             nan     0.0500    0.0003
##     40        0.0050             nan     0.0500    0.0002
##     60        0.0023             nan     0.0500    0.0000
##     80        0.0013             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.0500    0.0027
##      2        0.0359             nan     0.0500    0.0011
##      3        0.0333             nan     0.0500    0.0016
##      4        0.0315             nan     0.0500    0.0015
##      5        0.0296             nan     0.0500    0.0011
##      6        0.0284             nan     0.0500    0.0008
##      7        0.0270             nan     0.0500    0.0010
##      8        0.0257             nan     0.0500    0.0013
##      9        0.0247             nan     0.0500    0.0007
##     10        0.0241             nan     0.0500    0.0001
##     20        0.0156             nan     0.0500    0.0002
##     40        0.0085             nan     0.0500    0.0001
##     60        0.0051             nan     0.0500    0.0000
##     80        0.0036             nan     0.0500   -0.0000
##    100        0.0023             nan     0.0500   -0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.0500    0.0013
##      2        0.0367             nan     0.0500    0.0006
##      3        0.0345             nan     0.0500    0.0016
##      4        0.0319             nan     0.0500    0.0015
##      5        0.0293             nan     0.0500    0.0006
##      6        0.0269             nan     0.0500    0.0020
##      7        0.0249             nan     0.0500    0.0008
##      8        0.0233             nan     0.0500    0.0007
##      9        0.0215             nan     0.0500    0.0014
##     10        0.0198             nan     0.0500    0.0018
##     20        0.0102             nan     0.0500    0.0003
##     40        0.0029             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500    0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.0500    0.0021
##      2        0.0362             nan     0.0500    0.0026
##      3        0.0333             nan     0.0500    0.0023
##      4        0.0308             nan     0.0500    0.0018
##      5        0.0289             nan     0.0500    0.0021
##      6        0.0274             nan     0.0500    0.0014
##      7        0.0254             nan     0.0500    0.0003
##      8        0.0230             nan     0.0500    0.0017
##      9        0.0213             nan     0.0500    0.0014
##     10        0.0194             nan     0.0500    0.0006
##     20        0.0102             nan     0.0500    0.0002
##     40        0.0040             nan     0.0500    0.0002
##     60        0.0021             nan     0.0500    0.0001
##     80        0.0012             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.0500    0.0025
##      2        0.0360             nan     0.0500    0.0019
##      3        0.0338             nan     0.0500    0.0021
##      4        0.0317             nan     0.0500    0.0021
##      5        0.0297             nan     0.0500    0.0018
##      6        0.0284             nan     0.0500    0.0013
##      7        0.0265             nan     0.0500    0.0017
##      8        0.0251             nan     0.0500    0.0007
##      9        0.0243             nan     0.0500    0.0007
##     10        0.0235             nan     0.0500    0.0009
##     20        0.0149             nan     0.0500    0.0007
##     40        0.0074             nan     0.0500    0.0001
##     60        0.0044             nan     0.0500   -0.0000
##     80        0.0031             nan     0.0500    0.0000
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.0500   -0.0001
##      2        0.0380             nan     0.0500   -0.0002
##      3        0.0347             nan     0.0500    0.0033
##      4        0.0314             nan     0.0500    0.0022
##      5        0.0287             nan     0.0500    0.0030
##      6        0.0269             nan     0.0500    0.0013
##      7        0.0259             nan     0.0500    0.0008
##      8        0.0249             nan     0.0500    0.0005
##      9        0.0232             nan     0.0500    0.0002
##     10        0.0219             nan     0.0500    0.0007
##     20        0.0116             nan     0.0500    0.0003
##     40        0.0034             nan     0.0500    0.0000
##     60        0.0012             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.0500    0.0012
##      2        0.0355             nan     0.0500    0.0033
##      3        0.0331             nan     0.0500    0.0018
##      4        0.0317             nan     0.0500    0.0010
##      5        0.0295             nan     0.0500    0.0020
##      6        0.0289             nan     0.0500    0.0001
##      7        0.0264             nan     0.0500    0.0014
##      8        0.0249             nan     0.0500    0.0010
##      9        0.0236             nan     0.0500    0.0010
##     10        0.0219             nan     0.0500    0.0017
##     20        0.0116             nan     0.0500    0.0005
##     40        0.0045             nan     0.0500    0.0001
##     60        0.0019             nan     0.0500    0.0000
##     80        0.0010             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0389             nan     0.0500    0.0010
##      2        0.0361             nan     0.0500    0.0026
##      3        0.0341             nan     0.0500    0.0023
##      4        0.0326             nan     0.0500    0.0012
##      5        0.0311             nan     0.0500    0.0010
##      6        0.0289             nan     0.0500    0.0020
##      7        0.0273             nan     0.0500    0.0014
##      8        0.0258             nan     0.0500    0.0015
##      9        0.0244             nan     0.0500    0.0013
##     10        0.0231             nan     0.0500    0.0012
##     20        0.0133             nan     0.0500    0.0005
##     40        0.0059             nan     0.0500    0.0001
##     60        0.0036             nan     0.0500    0.0000
##     80        0.0023             nan     0.0500   -0.0000
##    100        0.0015             nan     0.0500   -0.0000
##    120        0.0011             nan     0.0500   -0.0000
##    140        0.0008             nan     0.0500    0.0000
##    160        0.0005             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500    0.0000
## 
## - Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0016
##      2        0.0320             nan     0.1000    0.0046
##      3        0.0280             nan     0.1000    0.0037
##      4        0.0240             nan     0.1000    0.0010
##      5        0.0212             nan     0.1000    0.0014
##      6        0.0192             nan     0.1000    0.0016
##      7        0.0176             nan     0.1000    0.0017
##      8        0.0156             nan     0.1000    0.0016
##      9        0.0143             nan     0.1000    0.0014
##     10        0.0127             nan     0.1000    0.0015
##     20        0.0059             nan     0.1000    0.0002
##     40        0.0018             nan     0.1000   -0.0001
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0358             nan     0.1000    0.0058
##      2        0.0316             nan     0.1000    0.0034
##      3        0.0285             nan     0.1000    0.0026
##      4        0.0267             nan     0.1000    0.0005
##      5        0.0246             nan     0.1000    0.0006
##      6        0.0227             nan     0.1000    0.0002
##      7        0.0201             nan     0.1000    0.0018
##      8        0.0184             nan     0.1000    0.0012
##      9        0.0158             nan     0.1000    0.0016
##     10        0.0147             nan     0.1000    0.0008
##     20        0.0063             nan     0.1000    0.0002
##     40        0.0022             nan     0.1000    0.0001
##     60        0.0010             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000    0.0000
##    100        0.0002             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0360             nan     0.1000    0.0045
##      2        0.0329             nan     0.1000    0.0039
##      3        0.0302             nan     0.1000    0.0007
##      4        0.0266             nan     0.1000    0.0034
##      5        0.0247             nan     0.1000   -0.0008
##      6        0.0220             nan     0.1000    0.0025
##      7        0.0201             nan     0.1000    0.0004
##      8        0.0189             nan     0.1000    0.0009
##      9        0.0175             nan     0.1000    0.0016
##     10        0.0162             nan     0.1000    0.0008
##     20        0.0072             nan     0.1000    0.0006
##     40        0.0033             nan     0.1000    0.0000
##     60        0.0019             nan     0.1000   -0.0000
##     80        0.0011             nan     0.1000   -0.0001
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0039
##      2        0.0347             nan     0.1000    0.0005
##      3        0.0295             nan     0.1000    0.0042
##      4        0.0249             nan     0.1000    0.0035
##      5        0.0225             nan     0.1000    0.0023
##      6        0.0197             nan     0.1000    0.0018
##      7        0.0183             nan     0.1000    0.0013
##      8        0.0156             nan     0.1000    0.0026
##      9        0.0134             nan     0.1000    0.0010
##     10        0.0121             nan     0.1000    0.0001
##     20        0.0033             nan     0.1000    0.0004
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0337             nan     0.1000    0.0060
##      2        0.0285             nan     0.1000    0.0030
##      3        0.0238             nan     0.1000    0.0042
##      4        0.0210             nan     0.1000    0.0006
##      5        0.0193             nan     0.1000   -0.0002
##      6        0.0165             nan     0.1000    0.0023
##      7        0.0152             nan     0.1000    0.0002
##      8        0.0140             nan     0.1000    0.0012
##      9        0.0128             nan     0.1000    0.0002
##     10        0.0117             nan     0.1000    0.0014
##     20        0.0036             nan     0.1000    0.0004
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0349             nan     0.1000    0.0056
##      2        0.0309             nan     0.1000    0.0012
##      3        0.0282             nan     0.1000   -0.0003
##      4        0.0255             nan     0.1000    0.0016
##      5        0.0233             nan     0.1000    0.0005
##      6        0.0217             nan     0.1000    0.0006
##      7        0.0207             nan     0.1000    0.0000
##      8        0.0179             nan     0.1000    0.0007
##      9        0.0166             nan     0.1000    0.0004
##     10        0.0147             nan     0.1000    0.0009
##     20        0.0077             nan     0.1000   -0.0000
##     40        0.0037             nan     0.1000   -0.0003
##     60        0.0019             nan     0.1000    0.0001
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000    0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0342             nan     0.1000    0.0034
##      2        0.0298             nan     0.1000    0.0001
##      3        0.0267             nan     0.1000    0.0020
##      4        0.0222             nan     0.1000    0.0033
##      5        0.0200             nan     0.1000    0.0011
##      6        0.0170             nan     0.1000    0.0022
##      7        0.0162             nan     0.1000   -0.0002
##      8        0.0138             nan     0.1000    0.0023
##      9        0.0116             nan     0.1000    0.0010
##     10        0.0098             nan     0.1000    0.0014
##     20        0.0030             nan     0.1000    0.0001
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0351             nan     0.1000    0.0041
##      2        0.0301             nan     0.1000    0.0048
##      3        0.0271             nan     0.1000    0.0022
##      4        0.0246             nan     0.1000    0.0015
##      5        0.0209             nan     0.1000    0.0023
##      6        0.0183             nan     0.1000   -0.0003
##      7        0.0161             nan     0.1000    0.0020
##      8        0.0140             nan     0.1000    0.0008
##      9        0.0122             nan     0.1000    0.0015
##     10        0.0108             nan     0.1000    0.0005
##     20        0.0042             nan     0.1000    0.0004
##     40        0.0008             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0357             nan     0.1000    0.0048
##      2        0.0317             nan     0.1000    0.0025
##      3        0.0271             nan     0.1000    0.0030
##      4        0.0232             nan     0.1000    0.0029
##      5        0.0200             nan     0.1000    0.0024
##      6        0.0184             nan     0.1000    0.0010
##      7        0.0168             nan     0.1000    0.0012
##      8        0.0157             nan     0.1000    0.0010
##      9        0.0140             nan     0.1000    0.0011
##     10        0.0131             nan     0.1000    0.0009
##     20        0.0069             nan     0.1000    0.0003
##     40        0.0026             nan     0.1000    0.0001
##     60        0.0013             nan     0.1000   -0.0000
##     80        0.0006             nan     0.1000   -0.0001
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0005
##      2        0.0431             nan     0.0100    0.0002
##      3        0.0425             nan     0.0100    0.0005
##      4        0.0420             nan     0.0100    0.0004
##      5        0.0416             nan     0.0100    0.0003
##      6        0.0411             nan     0.0100    0.0005
##      7        0.0406             nan     0.0100    0.0005
##      8        0.0403             nan     0.0100    0.0002
##      9        0.0397             nan     0.0100    0.0005
##     10        0.0393             nan     0.0100    0.0003
##     20        0.0349             nan     0.0100    0.0001
##     40        0.0276             nan     0.0100    0.0004
##     60        0.0221             nan     0.0100    0.0002
##     80        0.0180             nan     0.0100    0.0001
##    100        0.0150             nan     0.0100    0.0002
##    120        0.0126             nan     0.0100    0.0001
##    140        0.0106             nan     0.0100    0.0001
##    160        0.0092             nan     0.0100    0.0001
##    180        0.0077             nan     0.0100    0.0001
##    200        0.0064             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0001
##      2        0.0431             nan     0.0100    0.0002
##      3        0.0427             nan     0.0100    0.0005
##      4        0.0422             nan     0.0100    0.0004
##      5        0.0415             nan     0.0100    0.0006
##      6        0.0411             nan     0.0100    0.0005
##      7        0.0406             nan     0.0100    0.0005
##      8        0.0400             nan     0.0100    0.0005
##      9        0.0394             nan     0.0100    0.0004
##     10        0.0390             nan     0.0100    0.0005
##     20        0.0346             nan     0.0100    0.0004
##     40        0.0270             nan     0.0100    0.0003
##     60        0.0219             nan     0.0100    0.0000
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0151             nan     0.0100    0.0001
##    120        0.0124             nan     0.0100    0.0000
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0086             nan     0.0100    0.0000
##    180        0.0075             nan     0.0100   -0.0000
##    200        0.0065             nan     0.0100   -0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0004
##      2        0.0432             nan     0.0100    0.0005
##      3        0.0424             nan     0.0100    0.0005
##      4        0.0417             nan     0.0100    0.0006
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0404             nan     0.0100    0.0005
##      8        0.0400             nan     0.0100    0.0003
##      9        0.0395             nan     0.0100    0.0006
##     10        0.0391             nan     0.0100    0.0002
##     20        0.0346             nan     0.0100    0.0004
##     40        0.0283             nan     0.0100    0.0003
##     60        0.0230             nan     0.0100    0.0002
##     80        0.0191             nan     0.0100    0.0000
##    100        0.0157             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100    0.0001
##    140        0.0113             nan     0.0100    0.0000
##    160        0.0100             nan     0.0100    0.0000
##    180        0.0088             nan     0.0100   -0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0004
##      2        0.0429             nan     0.0100    0.0007
##      3        0.0422             nan     0.0100    0.0004
##      4        0.0414             nan     0.0100    0.0004
##      5        0.0410             nan     0.0100    0.0003
##      6        0.0403             nan     0.0100    0.0003
##      7        0.0396             nan     0.0100    0.0004
##      8        0.0390             nan     0.0100    0.0007
##      9        0.0383             nan     0.0100    0.0005
##     10        0.0376             nan     0.0100    0.0005
##     20        0.0329             nan     0.0100    0.0004
##     40        0.0248             nan     0.0100    0.0004
##     60        0.0188             nan     0.0100    0.0002
##     80        0.0144             nan     0.0100    0.0001
##    100        0.0112             nan     0.0100    0.0000
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0001
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0006
##      2        0.0428             nan     0.0100    0.0003
##      3        0.0425             nan     0.0100    0.0002
##      4        0.0418             nan     0.0100    0.0007
##      5        0.0413             nan     0.0100    0.0001
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0403             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0389             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0004
##     20        0.0335             nan     0.0100    0.0005
##     40        0.0254             nan     0.0100    0.0002
##     60        0.0196             nan     0.0100    0.0001
##     80        0.0151             nan     0.0100    0.0001
##    100        0.0119             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0000
##    140        0.0079             nan     0.0100    0.0000
##    160        0.0064             nan     0.0100    0.0000
##    180        0.0052             nan     0.0100   -0.0000
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0006
##      4        0.0417             nan     0.0100    0.0005
##      5        0.0411             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0001
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0397             nan     0.0100    0.0005
##      9        0.0392             nan     0.0100    0.0002
##     10        0.0387             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0005
##     40        0.0282             nan     0.0100    0.0003
##     60        0.0230             nan     0.0100    0.0000
##     80        0.0186             nan     0.0100    0.0001
##    100        0.0156             nan     0.0100    0.0000
##    120        0.0130             nan     0.0100    0.0001
##    140        0.0111             nan     0.0100    0.0001
##    160        0.0098             nan     0.0100   -0.0000
##    180        0.0085             nan     0.0100    0.0000
##    200        0.0078             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0004
##      2        0.0427             nan     0.0100    0.0005
##      3        0.0420             nan     0.0100    0.0004
##      4        0.0413             nan     0.0100    0.0006
##      5        0.0407             nan     0.0100    0.0004
##      6        0.0401             nan     0.0100    0.0005
##      7        0.0393             nan     0.0100    0.0008
##      8        0.0386             nan     0.0100    0.0007
##      9        0.0381             nan     0.0100    0.0005
##     10        0.0376             nan     0.0100    0.0006
##     20        0.0329             nan     0.0100    0.0004
##     40        0.0248             nan     0.0100    0.0004
##     60        0.0185             nan     0.0100    0.0002
##     80        0.0143             nan     0.0100    0.0001
##    100        0.0113             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0071             nan     0.0100   -0.0000
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0037             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0004
##      4        0.0417             nan     0.0100    0.0005
##      5        0.0410             nan     0.0100    0.0007
##      6        0.0403             nan     0.0100    0.0006
##      7        0.0397             nan     0.0100    0.0006
##      8        0.0392             nan     0.0100    0.0004
##      9        0.0385             nan     0.0100    0.0004
##     10        0.0379             nan     0.0100    0.0001
##     20        0.0334             nan     0.0100    0.0002
##     40        0.0260             nan     0.0100    0.0001
##     60        0.0204             nan     0.0100    0.0000
##     80        0.0154             nan     0.0100    0.0002
##    100        0.0120             nan     0.0100   -0.0000
##    120        0.0096             nan     0.0100    0.0000
##    140        0.0076             nan     0.0100    0.0000
##    160        0.0061             nan     0.0100    0.0001
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0000
##      2        0.0428             nan     0.0100    0.0006
##      3        0.0423             nan     0.0100    0.0005
##      4        0.0417             nan     0.0100    0.0005
##      5        0.0411             nan     0.0100    0.0006
##      6        0.0406             nan     0.0100    0.0005
##      7        0.0402             nan     0.0100    0.0004
##      8        0.0398             nan     0.0100    0.0003
##      9        0.0392             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0004
##     40        0.0275             nan     0.0100    0.0002
##     60        0.0223             nan     0.0100    0.0001
##     80        0.0188             nan     0.0100    0.0002
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100   -0.0000
##    140        0.0114             nan     0.0100    0.0001
##    160        0.0101             nan     0.0100    0.0001
##    180        0.0088             nan     0.0100    0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0420             nan     0.0500   -0.0002
##      2        0.0396             nan     0.0500    0.0008
##      3        0.0370             nan     0.0500    0.0018
##      4        0.0355             nan     0.0500    0.0008
##      5        0.0341             nan     0.0500    0.0008
##      6        0.0316             nan     0.0500    0.0016
##      7        0.0296             nan     0.0500    0.0013
##      8        0.0281             nan     0.0500    0.0014
##      9        0.0268             nan     0.0500    0.0010
##     10        0.0253             nan     0.0500    0.0010
##     20        0.0141             nan     0.0500    0.0010
##     40        0.0058             nan     0.0500    0.0000
##     60        0.0030             nan     0.0500    0.0001
##     80        0.0017             nan     0.0500    0.0000
##    100        0.0010             nan     0.0500   -0.0001
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0500   -0.0006
##      2        0.0399             nan     0.0500    0.0026
##      3        0.0370             nan     0.0500    0.0012
##      4        0.0352             nan     0.0500    0.0016
##      5        0.0340             nan     0.0500    0.0003
##      6        0.0318             nan     0.0500    0.0021
##      7        0.0298             nan     0.0500    0.0017
##      8        0.0289             nan     0.0500    0.0011
##      9        0.0274             nan     0.0500    0.0008
##     10        0.0266             nan     0.0500    0.0008
##     20        0.0173             nan     0.0500    0.0008
##     40        0.0066             nan     0.0500    0.0000
##     60        0.0033             nan     0.0500   -0.0001
##     80        0.0018             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0500   -0.0000
##      2        0.0402             nan     0.0500    0.0016
##      3        0.0376             nan     0.0500    0.0024
##      4        0.0355             nan     0.0500    0.0021
##      5        0.0332             nan     0.0500    0.0019
##      6        0.0314             nan     0.0500    0.0011
##      7        0.0295             nan     0.0500    0.0008
##      8        0.0282             nan     0.0500    0.0011
##      9        0.0267             nan     0.0500    0.0014
##     10        0.0248             nan     0.0500    0.0015
##     20        0.0156             nan     0.0500    0.0003
##     40        0.0080             nan     0.0500    0.0001
##     60        0.0046             nan     0.0500   -0.0000
##     80        0.0028             nan     0.0500    0.0001
##    100        0.0019             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0033
##      2        0.0372             nan     0.0500    0.0030
##      3        0.0347             nan     0.0500    0.0017
##      4        0.0319             nan     0.0500    0.0029
##      5        0.0305             nan     0.0500    0.0005
##      6        0.0283             nan     0.0500    0.0016
##      7        0.0260             nan     0.0500    0.0016
##      8        0.0246             nan     0.0500    0.0000
##      9        0.0231             nan     0.0500    0.0011
##     10        0.0215             nan     0.0500    0.0010
##     20        0.0115             nan     0.0500    0.0003
##     40        0.0039             nan     0.0500    0.0001
##     60        0.0015             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0027
##      2        0.0383             nan     0.0500    0.0031
##      3        0.0358             nan     0.0500    0.0022
##      4        0.0328             nan     0.0500    0.0016
##      5        0.0316             nan     0.0500   -0.0013
##      6        0.0295             nan     0.0500    0.0023
##      7        0.0277             nan     0.0500    0.0013
##      8        0.0263             nan     0.0500    0.0004
##      9        0.0240             nan     0.0500    0.0015
##     10        0.0225             nan     0.0500    0.0018
##     20        0.0121             nan     0.0500    0.0003
##     40        0.0043             nan     0.0500    0.0000
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500    0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0019
##      2        0.0397             nan     0.0500    0.0019
##      3        0.0377             nan     0.0500    0.0016
##      4        0.0351             nan     0.0500    0.0025
##      5        0.0332             nan     0.0500    0.0023
##      6        0.0319             nan     0.0500    0.0008
##      7        0.0299             nan     0.0500    0.0017
##      8        0.0278             nan     0.0500    0.0016
##      9        0.0270             nan     0.0500   -0.0005
##     10        0.0259             nan     0.0500    0.0002
##     20        0.0164             nan     0.0500   -0.0002
##     40        0.0094             nan     0.0500    0.0001
##     60        0.0058             nan     0.0500    0.0001
##     80        0.0038             nan     0.0500    0.0000
##    100        0.0024             nan     0.0500    0.0000
##    120        0.0019             nan     0.0500   -0.0001
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0015
##      2        0.0401             nan     0.0500   -0.0004
##      3        0.0384             nan     0.0500    0.0011
##      4        0.0351             nan     0.0500    0.0019
##      5        0.0331             nan     0.0500    0.0010
##      6        0.0302             nan     0.0500    0.0017
##      7        0.0279             nan     0.0500    0.0013
##      8        0.0262             nan     0.0500    0.0001
##      9        0.0241             nan     0.0500    0.0013
##     10        0.0220             nan     0.0500    0.0016
##     20        0.0108             nan     0.0500    0.0006
##     40        0.0033             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0023
##      2        0.0377             nan     0.0500    0.0021
##      3        0.0347             nan     0.0500    0.0015
##      4        0.0321             nan     0.0500    0.0013
##      5        0.0292             nan     0.0500    0.0020
##      6        0.0279             nan     0.0500   -0.0010
##      7        0.0260             nan     0.0500    0.0017
##      8        0.0238             nan     0.0500    0.0019
##      9        0.0217             nan     0.0500    0.0009
##     10        0.0200             nan     0.0500    0.0016
##     20        0.0114             nan     0.0500    0.0007
##     40        0.0045             nan     0.0500   -0.0001
##     60        0.0022             nan     0.0500   -0.0000
##     80        0.0012             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0025
##      2        0.0394             nan     0.0500    0.0020
##      3        0.0378             nan     0.0500    0.0007
##      4        0.0356             nan     0.0500    0.0024
##      5        0.0336             nan     0.0500    0.0016
##      6        0.0315             nan     0.0500    0.0019
##      7        0.0302             nan     0.0500    0.0000
##      8        0.0282             nan     0.0500    0.0018
##      9        0.0264             nan     0.0500    0.0014
##     10        0.0248             nan     0.0500    0.0013
##     20        0.0156             nan     0.0500    0.0007
##     40        0.0082             nan     0.0500    0.0002
##     60        0.0052             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500   -0.0001
##    100        0.0022             nan     0.0500    0.0000
##    120        0.0015             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0012
##      2        0.0335             nan     0.1000    0.0047
##      3        0.0313             nan     0.1000    0.0005
##      4        0.0277             nan     0.1000    0.0008
##      5        0.0259             nan     0.1000    0.0007
##      6        0.0225             nan     0.1000    0.0014
##      7        0.0203             nan     0.1000    0.0006
##      8        0.0185             nan     0.1000    0.0016
##      9        0.0170             nan     0.1000    0.0005
##     10        0.0158             nan     0.1000    0.0010
##     20        0.0070             nan     0.1000   -0.0002
##     40        0.0019             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0041
##      2        0.0338             nan     0.1000    0.0017
##      3        0.0317             nan     0.1000   -0.0001
##      4        0.0275             nan     0.1000    0.0030
##      5        0.0246             nan     0.1000    0.0020
##      6        0.0224             nan     0.1000    0.0016
##      7        0.0200             nan     0.1000    0.0024
##      8        0.0188             nan     0.1000    0.0003
##      9        0.0174             nan     0.1000    0.0006
##     10        0.0163             nan     0.1000    0.0009
##     20        0.0070             nan     0.1000    0.0003
##     40        0.0019             nan     0.1000    0.0000
##     60        0.0008             nan     0.1000   -0.0000
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.1000    0.0048
##      2        0.0349             nan     0.1000    0.0025
##      3        0.0315             nan     0.1000    0.0036
##      4        0.0289             nan     0.1000    0.0017
##      5        0.0258             nan     0.1000    0.0011
##      6        0.0233             nan     0.1000    0.0022
##      7        0.0215             nan     0.1000    0.0020
##      8        0.0206             nan     0.1000   -0.0002
##      9        0.0184             nan     0.1000    0.0011
##     10        0.0174             nan     0.1000   -0.0001
##     20        0.0098             nan     0.1000    0.0004
##     40        0.0039             nan     0.1000   -0.0001
##     60        0.0020             nan     0.1000    0.0000
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000    0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0054
##      2        0.0321             nan     0.1000    0.0054
##      3        0.0280             nan     0.1000    0.0030
##      4        0.0233             nan     0.1000    0.0032
##      5        0.0201             nan     0.1000    0.0035
##      6        0.0183             nan     0.1000    0.0013
##      7        0.0165             nan     0.1000    0.0016
##      8        0.0148             nan     0.1000    0.0014
##      9        0.0131             nan     0.1000    0.0023
##     10        0.0120             nan     0.1000    0.0008
##     20        0.0041             nan     0.1000    0.0002
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.1000    0.0060
##      2        0.0312             nan     0.1000    0.0052
##      3        0.0278             nan     0.1000   -0.0011
##      4        0.0248             nan     0.1000    0.0018
##      5        0.0216             nan     0.1000    0.0015
##      6        0.0180             nan     0.1000    0.0024
##      7        0.0159             nan     0.1000    0.0014
##      8        0.0149             nan     0.1000    0.0001
##      9        0.0130             nan     0.1000    0.0011
##     10        0.0111             nan     0.1000    0.0019
##     20        0.0037             nan     0.1000    0.0002
##     40        0.0010             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0382             nan     0.1000    0.0024
##      2        0.0345             nan     0.1000    0.0030
##      3        0.0306             nan     0.1000    0.0041
##      4        0.0281             nan     0.1000    0.0011
##      5        0.0266             nan     0.1000   -0.0007
##      6        0.0252             nan     0.1000    0.0004
##      7        0.0228             nan     0.1000    0.0016
##      8        0.0213             nan     0.1000    0.0009
##      9        0.0201             nan     0.1000    0.0009
##     10        0.0176             nan     0.1000    0.0018
##     20        0.0099             nan     0.1000   -0.0003
##     40        0.0042             nan     0.1000    0.0000
##     60        0.0018             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0386             nan     0.1000    0.0028
##      2        0.0340             nan     0.1000    0.0026
##      3        0.0286             nan     0.1000    0.0021
##      4        0.0258             nan     0.1000    0.0000
##      5        0.0210             nan     0.1000    0.0034
##      6        0.0181             nan     0.1000    0.0027
##      7        0.0163             nan     0.1000    0.0004
##      8        0.0144             nan     0.1000    0.0016
##      9        0.0126             nan     0.1000    0.0012
##     10        0.0108             nan     0.1000    0.0009
##     20        0.0037             nan     0.1000   -0.0001
##     40        0.0007             nan     0.1000    0.0001
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.1000    0.0048
##      2        0.0319             nan     0.1000    0.0016
##      3        0.0299             nan     0.1000    0.0014
##      4        0.0255             nan     0.1000    0.0042
##      5        0.0218             nan     0.1000    0.0037
##      6        0.0184             nan     0.1000    0.0018
##      7        0.0171             nan     0.1000    0.0008
##      8        0.0154             nan     0.1000    0.0014
##      9        0.0133             nan     0.1000    0.0019
##     10        0.0117             nan     0.1000    0.0018
##     20        0.0040             nan     0.1000    0.0004
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0058
##      2        0.0329             nan     0.1000    0.0042
##      3        0.0287             nan     0.1000    0.0038
##      4        0.0254             nan     0.1000    0.0028
##      5        0.0238             nan     0.1000    0.0007
##      6        0.0218             nan     0.1000    0.0017
##      7        0.0204             nan     0.1000    0.0006
##      8        0.0200             nan     0.1000   -0.0013
##      9        0.0189             nan     0.1000   -0.0006
##     10        0.0178             nan     0.1000    0.0013
##     20        0.0116             nan     0.1000   -0.0003
##     40        0.0043             nan     0.1000    0.0001
##     60        0.0022             nan     0.1000   -0.0001
##     80        0.0009             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0004
##      2        0.0420             nan     0.0100    0.0003
##      3        0.0417             nan     0.0100    0.0003
##      4        0.0411             nan     0.0100    0.0006
##      5        0.0410             nan     0.0100   -0.0002
##      6        0.0406             nan     0.0100    0.0002
##      7        0.0400             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100    0.0003
##      9        0.0389             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0005
##     20        0.0343             nan     0.0100    0.0002
##     40        0.0270             nan     0.0100    0.0003
##     60        0.0219             nan     0.0100   -0.0000
##     80        0.0180             nan     0.0100    0.0001
##    100        0.0150             nan     0.0100   -0.0000
##    120        0.0123             nan     0.0100   -0.0000
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0086             nan     0.0100    0.0001
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0001
## 
## - Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0005
##      2        0.0421             nan     0.0100    0.0002
##      3        0.0416             nan     0.0100    0.0002
##      4        0.0411             nan     0.0100    0.0004
##      5        0.0406             nan     0.0100    0.0005
##      6        0.0403             nan     0.0100    0.0004
##      7        0.0397             nan     0.0100    0.0003
##      8        0.0392             nan     0.0100    0.0005
##      9        0.0387             nan     0.0100    0.0005
##     10        0.0381             nan     0.0100    0.0005
##     20        0.0338             nan     0.0100    0.0004
##     40        0.0278             nan     0.0100    0.0002
##     60        0.0224             nan     0.0100    0.0000
##     80        0.0182             nan     0.0100    0.0000
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0111             nan     0.0100    0.0001
##    160        0.0096             nan     0.0100    0.0000
##    180        0.0081             nan     0.0100   -0.0000
##    200        0.0069             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0004
##      2        0.0421             nan     0.0100   -0.0000
##      3        0.0417             nan     0.0100    0.0004
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0005
##      6        0.0402             nan     0.0100    0.0005
##      7        0.0397             nan     0.0100    0.0004
##      8        0.0393             nan     0.0100    0.0004
##      9        0.0391             nan     0.0100    0.0001
##     10        0.0386             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0004
##     40        0.0278             nan     0.0100    0.0001
##     60        0.0230             nan     0.0100   -0.0001
##     80        0.0192             nan     0.0100    0.0001
##    100        0.0165             nan     0.0100    0.0001
##    120        0.0143             nan     0.0100    0.0000
##    140        0.0128             nan     0.0100    0.0000
##    160        0.0112             nan     0.0100    0.0000
##    180        0.0097             nan     0.0100    0.0000
##    200        0.0089             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0003
##      2        0.0418             nan     0.0100    0.0004
##      3        0.0412             nan     0.0100    0.0007
##      4        0.0406             nan     0.0100    0.0006
##      5        0.0399             nan     0.0100    0.0005
##      6        0.0393             nan     0.0100    0.0007
##      7        0.0386             nan     0.0100    0.0005
##      8        0.0380             nan     0.0100    0.0005
##      9        0.0373             nan     0.0100    0.0005
##     10        0.0368             nan     0.0100    0.0006
##     20        0.0327             nan     0.0100    0.0003
##     40        0.0252             nan     0.0100    0.0002
##     60        0.0190             nan     0.0100    0.0002
##     80        0.0147             nan     0.0100    0.0000
##    100        0.0115             nan     0.0100    0.0001
##    120        0.0092             nan     0.0100    0.0000
##    140        0.0073             nan     0.0100    0.0000
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0001
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0003
##      2        0.0419             nan     0.0100    0.0005
##      3        0.0414             nan     0.0100    0.0005
##      4        0.0411             nan     0.0100    0.0003
##      5        0.0404             nan     0.0100    0.0007
##      6        0.0398             nan     0.0100    0.0006
##      7        0.0394             nan     0.0100    0.0002
##      8        0.0392             nan     0.0100   -0.0001
##      9        0.0388             nan     0.0100   -0.0000
##     10        0.0383             nan     0.0100    0.0006
##     20        0.0332             nan     0.0100    0.0001
##     40        0.0253             nan     0.0100    0.0005
##     60        0.0193             nan     0.0100   -0.0000
##     80        0.0155             nan     0.0100    0.0001
##    100        0.0124             nan     0.0100    0.0001
##    120        0.0098             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0000
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0004
##      2        0.0422             nan     0.0100    0.0001
##      3        0.0418             nan     0.0100    0.0005
##      4        0.0412             nan     0.0100    0.0006
##      5        0.0409             nan     0.0100    0.0001
##      6        0.0406             nan     0.0100    0.0002
##      7        0.0401             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0003
##      9        0.0390             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100   -0.0000
##     20        0.0341             nan     0.0100    0.0003
##     40        0.0267             nan     0.0100    0.0002
##     60        0.0218             nan     0.0100    0.0002
##     80        0.0180             nan     0.0100   -0.0000
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0117             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0090             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0006
##      2        0.0416             nan     0.0100    0.0005
##      3        0.0411             nan     0.0100    0.0004
##      4        0.0405             nan     0.0100    0.0006
##      5        0.0401             nan     0.0100    0.0000
##      6        0.0396             nan     0.0100    0.0002
##      7        0.0389             nan     0.0100    0.0005
##      8        0.0386             nan     0.0100    0.0001
##      9        0.0380             nan     0.0100    0.0004
##     10        0.0374             nan     0.0100    0.0004
##     20        0.0329             nan     0.0100    0.0003
##     40        0.0242             nan     0.0100    0.0001
##     60        0.0184             nan     0.0100    0.0001
##     80        0.0142             nan     0.0100    0.0001
##    100        0.0106             nan     0.0100    0.0001
##    120        0.0083             nan     0.0100    0.0001
##    140        0.0065             nan     0.0100    0.0000
##    160        0.0052             nan     0.0100    0.0000
##    180        0.0041             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100   -0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0005
##      2        0.0416             nan     0.0100    0.0006
##      3        0.0410             nan     0.0100    0.0005
##      4        0.0405             nan     0.0100    0.0004
##      5        0.0400             nan     0.0100    0.0005
##      6        0.0394             nan     0.0100    0.0006
##      7        0.0388             nan     0.0100    0.0005
##      8        0.0381             nan     0.0100    0.0006
##      9        0.0376             nan     0.0100    0.0005
##     10        0.0369             nan     0.0100    0.0005
##     20        0.0322             nan     0.0100    0.0002
##     40        0.0248             nan     0.0100    0.0003
##     60        0.0187             nan     0.0100    0.0000
##     80        0.0149             nan     0.0100    0.0001
##    100        0.0115             nan     0.0100    0.0001
##    120        0.0092             nan     0.0100    0.0000
##    140        0.0075             nan     0.0100    0.0000
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0051             nan     0.0100   -0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0003
##      2        0.0421             nan     0.0100    0.0002
##      3        0.0417             nan     0.0100    0.0003
##      4        0.0411             nan     0.0100    0.0005
##      5        0.0406             nan     0.0100    0.0005
##      6        0.0400             nan     0.0100    0.0004
##      7        0.0394             nan     0.0100    0.0006
##      8        0.0388             nan     0.0100    0.0004
##      9        0.0382             nan     0.0100    0.0005
##     10        0.0379             nan     0.0100    0.0002
##     20        0.0334             nan     0.0100    0.0003
##     40        0.0275             nan     0.0100    0.0001
##     60        0.0231             nan     0.0100    0.0002
##     80        0.0192             nan     0.0100    0.0002
##    100        0.0161             nan     0.0100    0.0001
##    120        0.0135             nan     0.0100    0.0001
##    140        0.0118             nan     0.0100    0.0001
##    160        0.0104             nan     0.0100   -0.0000
##    180        0.0090             nan     0.0100    0.0000
##    200        0.0083             nan     0.0100   -0.0000
## 
## - Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0027
##      2        0.0382             nan     0.0500    0.0016
##      3        0.0356             nan     0.0500    0.0020
##      4        0.0333             nan     0.0500    0.0021
##      5        0.0318             nan     0.0500    0.0015
##      6        0.0296             nan     0.0500    0.0016
##      7        0.0287             nan     0.0500    0.0002
##      8        0.0268             nan     0.0500    0.0018
##      9        0.0256             nan     0.0500   -0.0001
##     10        0.0244             nan     0.0500    0.0011
##     20        0.0145             nan     0.0500    0.0006
##     40        0.0064             nan     0.0500    0.0000
##     60        0.0028             nan     0.0500   -0.0000
##     80        0.0015             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0008
##      2        0.0388             nan     0.0500    0.0020
##      3        0.0367             nan     0.0500    0.0010
##      4        0.0346             nan     0.0500    0.0015
##      5        0.0326             nan     0.0500    0.0019
##      6        0.0308             nan     0.0500    0.0018
##      7        0.0284             nan     0.0500    0.0011
##      8        0.0274             nan     0.0500   -0.0001
##      9        0.0254             nan     0.0500    0.0016
##     10        0.0244             nan     0.0500    0.0000
##     20        0.0149             nan     0.0500    0.0002
##     40        0.0062             nan     0.0500   -0.0001
##     60        0.0037             nan     0.0500   -0.0000
##     80        0.0022             nan     0.0500   -0.0001
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0025
##      2        0.0385             nan     0.0500    0.0013
##      3        0.0356             nan     0.0500    0.0025
##      4        0.0338             nan     0.0500    0.0020
##      5        0.0318             nan     0.0500    0.0018
##      6        0.0302             nan     0.0500    0.0018
##      7        0.0286             nan     0.0500    0.0014
##      8        0.0268             nan     0.0500    0.0017
##      9        0.0258             nan     0.0500    0.0003
##     10        0.0248             nan     0.0500    0.0001
##     20        0.0161             nan     0.0500    0.0007
##     40        0.0085             nan     0.0500    0.0003
##     60        0.0052             nan     0.0500   -0.0001
##     80        0.0033             nan     0.0500    0.0000
##    100        0.0025             nan     0.0500   -0.0000
##    120        0.0019             nan     0.0500   -0.0000
##    140        0.0013             nan     0.0500    0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500    0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0017
##      2        0.0370             nan     0.0500    0.0033
##      3        0.0340             nan     0.0500    0.0025
##      4        0.0314             nan     0.0500    0.0019
##      5        0.0296             nan     0.0500    0.0015
##      6        0.0280             nan     0.0500    0.0016
##      7        0.0258             nan     0.0500    0.0019
##      8        0.0243             nan     0.0500    0.0011
##      9        0.0228             nan     0.0500    0.0010
##     10        0.0213             nan     0.0500    0.0018
##     20        0.0108             nan     0.0500    0.0005
##     40        0.0040             nan     0.0500    0.0002
##     60        0.0015             nan     0.0500    0.0001
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0029
##      2        0.0380             nan     0.0500    0.0018
##      3        0.0367             nan     0.0500    0.0012
##      4        0.0337             nan     0.0500    0.0024
##      5        0.0316             nan     0.0500    0.0019
##      6        0.0294             nan     0.0500    0.0014
##      7        0.0268             nan     0.0500    0.0018
##      8        0.0256             nan     0.0500    0.0012
##      9        0.0236             nan     0.0500    0.0017
##     10        0.0222             nan     0.0500    0.0014
##     20        0.0130             nan     0.0500    0.0007
##     40        0.0046             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500    0.0000
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0014
##      2        0.0387             nan     0.0500    0.0015
##      3        0.0365             nan     0.0500    0.0025
##      4        0.0346             nan     0.0500    0.0006
##      5        0.0332             nan     0.0500    0.0010
##      6        0.0319             nan     0.0500    0.0010
##      7        0.0294             nan     0.0500    0.0015
##      8        0.0284             nan     0.0500    0.0008
##      9        0.0277             nan     0.0500   -0.0000
##     10        0.0265             nan     0.0500    0.0014
##     20        0.0168             nan     0.0500    0.0000
##     40        0.0084             nan     0.0500    0.0001
##     60        0.0049             nan     0.0500   -0.0001
##     80        0.0031             nan     0.0500    0.0001
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.0500    0.0023
##      2        0.0370             nan     0.0500    0.0024
##      3        0.0340             nan     0.0500    0.0029
##      4        0.0318             nan     0.0500    0.0002
##      5        0.0291             nan     0.0500    0.0025
##      6        0.0271             nan     0.0500    0.0013
##      7        0.0257             nan     0.0500    0.0014
##      8        0.0244             nan     0.0500    0.0014
##      9        0.0227             nan     0.0500    0.0011
##     10        0.0208             nan     0.0500    0.0017
##     20        0.0097             nan     0.0500    0.0007
##     40        0.0028             nan     0.0500    0.0000
##     60        0.0011             nan     0.0500    0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0017
##      2        0.0382             nan     0.0500    0.0018
##      3        0.0358             nan     0.0500    0.0020
##      4        0.0327             nan     0.0500    0.0014
##      5        0.0310             nan     0.0500    0.0006
##      6        0.0298             nan     0.0500    0.0005
##      7        0.0274             nan     0.0500    0.0027
##      8        0.0256             nan     0.0500    0.0005
##      9        0.0240             nan     0.0500    0.0013
##     10        0.0231             nan     0.0500    0.0007
##     20        0.0129             nan     0.0500    0.0008
##     40        0.0052             nan     0.0500    0.0002
##     60        0.0021             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0012
##      2        0.0388             nan     0.0500    0.0020
##      3        0.0380             nan     0.0500   -0.0005
##      4        0.0362             nan     0.0500    0.0013
##      5        0.0352             nan     0.0500   -0.0016
##      6        0.0327             nan     0.0500    0.0021
##      7        0.0314             nan     0.0500    0.0010
##      8        0.0298             nan     0.0500    0.0012
##      9        0.0277             nan     0.0500    0.0014
##     10        0.0261             nan     0.0500    0.0014
##     20        0.0164             nan     0.0500    0.0006
##     40        0.0078             nan     0.0500    0.0002
##     60        0.0050             nan     0.0500   -0.0000
##     80        0.0034             nan     0.0500   -0.0000
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0013             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0034
##      2        0.0338             nan     0.1000    0.0029
##      3        0.0317             nan     0.1000    0.0010
##      4        0.0306             nan     0.1000   -0.0004
##      5        0.0266             nan     0.1000    0.0035
##      6        0.0230             nan     0.1000    0.0021
##      7        0.0212             nan     0.1000    0.0016
##      8        0.0207             nan     0.1000    0.0000
##      9        0.0185             nan     0.1000    0.0017
##     10        0.0171             nan     0.1000    0.0009
##     20        0.0072             nan     0.1000   -0.0014
##     40        0.0023             nan     0.1000   -0.0001
##     60        0.0008             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0051
##      2        0.0323             nan     0.1000    0.0041
##      3        0.0289             nan     0.1000    0.0032
##      4        0.0257             nan     0.1000    0.0035
##      5        0.0244             nan     0.1000   -0.0004
##      6        0.0207             nan     0.1000    0.0020
##      7        0.0193             nan     0.1000    0.0012
##      8        0.0180             nan     0.1000    0.0015
##      9        0.0157             nan     0.1000    0.0005
##     10        0.0146             nan     0.1000   -0.0000
##     20        0.0078             nan     0.1000   -0.0005
##     40        0.0026             nan     0.1000   -0.0003
##     60        0.0012             nan     0.1000    0.0001
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.1000    0.0004
##      2        0.0365             nan     0.1000    0.0028
##      3        0.0323             nan     0.1000    0.0038
##      4        0.0287             nan     0.1000    0.0035
##      5        0.0269             nan     0.1000    0.0010
##      6        0.0244             nan     0.1000    0.0026
##      7        0.0221             nan     0.1000    0.0017
##      8        0.0197             nan     0.1000    0.0011
##      9        0.0180             nan     0.1000    0.0017
##     10        0.0168             nan     0.1000   -0.0002
##     20        0.0099             nan     0.1000    0.0005
##     40        0.0036             nan     0.1000    0.0002
##     60        0.0015             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0021
##      2        0.0337             nan     0.1000    0.0017
##      3        0.0285             nan     0.1000    0.0033
##      4        0.0240             nan     0.1000    0.0027
##      5        0.0202             nan     0.1000    0.0031
##      6        0.0182             nan     0.1000    0.0014
##      7        0.0158             nan     0.1000    0.0018
##      8        0.0143             nan     0.1000    0.0001
##      9        0.0139             nan     0.1000   -0.0003
##     10        0.0115             nan     0.1000    0.0016
##     20        0.0041             nan     0.1000   -0.0001
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.1000    0.0073
##      2        0.0328             nan     0.1000    0.0036
##      3        0.0280             nan     0.1000    0.0040
##      4        0.0241             nan     0.1000    0.0023
##      5        0.0227             nan     0.1000    0.0004
##      6        0.0214             nan     0.1000    0.0010
##      7        0.0186             nan     0.1000    0.0022
##      8        0.0160             nan     0.1000    0.0017
##      9        0.0140             nan     0.1000    0.0013
##     10        0.0123             nan     0.1000    0.0014
##     20        0.0044             nan     0.1000    0.0004
##     40        0.0010             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.1000    0.0046
##      2        0.0310             nan     0.1000    0.0047
##      3        0.0285             nan     0.1000    0.0013
##      4        0.0252             nan     0.1000    0.0033
##      5        0.0233             nan     0.1000    0.0017
##      6        0.0216             nan     0.1000    0.0010
##      7        0.0193             nan     0.1000    0.0023
##      8        0.0170             nan     0.1000    0.0014
##      9        0.0154             nan     0.1000    0.0006
##     10        0.0146             nan     0.1000   -0.0001
##     20        0.0072             nan     0.1000   -0.0002
##     40        0.0027             nan     0.1000    0.0001
##     60        0.0013             nan     0.1000   -0.0001
##     80        0.0006             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000   -0.0001
##      2        0.0327             nan     0.1000    0.0021
##      3        0.0287             nan     0.1000    0.0045
##      4        0.0246             nan     0.1000    0.0033
##      5        0.0209             nan     0.1000    0.0015
##      6        0.0179             nan     0.1000    0.0026
##      7        0.0165             nan     0.1000   -0.0005
##      8        0.0142             nan     0.1000    0.0018
##      9        0.0124             nan     0.1000    0.0011
##     10        0.0109             nan     0.1000    0.0017
##     20        0.0029             nan     0.1000    0.0000
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.1000    0.0046
##      2        0.0325             nan     0.1000    0.0048
##      3        0.0289             nan     0.1000    0.0036
##      4        0.0243             nan     0.1000    0.0026
##      5        0.0215             nan     0.1000    0.0017
##      6        0.0188             nan     0.1000    0.0012
##      7        0.0168             nan     0.1000    0.0002
##      8        0.0140             nan     0.1000    0.0016
##      9        0.0119             nan     0.1000    0.0019
##     10        0.0110             nan     0.1000    0.0002
##     20        0.0045             nan     0.1000    0.0001
##     40        0.0010             nan     0.1000   -0.0001
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0382             nan     0.1000    0.0010
##      2        0.0345             nan     0.1000    0.0014
##      3        0.0310             nan     0.1000    0.0036
##      4        0.0277             nan     0.1000    0.0030
##      5        0.0242             nan     0.1000    0.0029
##      6        0.0219             nan     0.1000    0.0024
##      7        0.0209             nan     0.1000    0.0006
##      8        0.0190             nan     0.1000    0.0015
##      9        0.0171             nan     0.1000    0.0017
##     10        0.0165             nan     0.1000   -0.0006
##     20        0.0096             nan     0.1000   -0.0004
##     40        0.0040             nan     0.1000   -0.0001
##     60        0.0016             nan     0.1000    0.0001
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0006
##      2        0.0430             nan     0.0100    0.0004
##      3        0.0425             nan     0.0100    0.0005
##      4        0.0423             nan     0.0100    0.0001
##      5        0.0417             nan     0.0100    0.0005
##      6        0.0412             nan     0.0100    0.0006
##      7        0.0408             nan     0.0100    0.0003
##      8        0.0402             nan     0.0100    0.0002
##      9        0.0395             nan     0.0100    0.0005
##     10        0.0390             nan     0.0100    0.0003
##     20        0.0350             nan     0.0100    0.0004
##     40        0.0283             nan     0.0100    0.0003
##     60        0.0227             nan     0.0100    0.0001
##     80        0.0183             nan     0.0100    0.0001
##    100        0.0151             nan     0.0100    0.0001
##    120        0.0122             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0085             nan     0.0100    0.0000
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0063             nan     0.0100   -0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0001
##      2        0.0431             nan     0.0100    0.0003
##      3        0.0425             nan     0.0100    0.0006
##      4        0.0421             nan     0.0100    0.0005
##      5        0.0414             nan     0.0100    0.0006
##      6        0.0409             nan     0.0100    0.0000
##      7        0.0404             nan     0.0100    0.0005
##      8        0.0399             nan     0.0100    0.0005
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0390             nan     0.0100    0.0005
##     20        0.0350             nan     0.0100    0.0005
##     40        0.0282             nan     0.0100    0.0000
##     60        0.0229             nan     0.0100    0.0002
##     80        0.0183             nan     0.0100    0.0002
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0125             nan     0.0100    0.0001
##    140        0.0105             nan     0.0100    0.0000
##    160        0.0089             nan     0.0100    0.0001
##    180        0.0074             nan     0.0100   -0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0006
##      2        0.0429             nan     0.0100    0.0006
##      3        0.0423             nan     0.0100    0.0006
##      4        0.0418             nan     0.0100    0.0001
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0411             nan     0.0100   -0.0000
##      7        0.0406             nan     0.0100    0.0004
##      8        0.0401             nan     0.0100    0.0001
##      9        0.0396             nan     0.0100    0.0003
##     10        0.0391             nan     0.0100    0.0005
##     20        0.0347             nan     0.0100    0.0004
##     40        0.0278             nan     0.0100    0.0003
##     60        0.0228             nan     0.0100    0.0003
##     80        0.0192             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0120             nan     0.0100   -0.0000
##    160        0.0103             nan     0.0100    0.0001
##    180        0.0091             nan     0.0100    0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0425             nan     0.0100    0.0006
##      3        0.0421             nan     0.0100    0.0001
##      4        0.0415             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0006
##      6        0.0402             nan     0.0100    0.0004
##      7        0.0399             nan     0.0100    0.0000
##      8        0.0392             nan     0.0100    0.0004
##      9        0.0385             nan     0.0100    0.0005
##     10        0.0378             nan     0.0100    0.0005
##     20        0.0326             nan     0.0100    0.0005
##     40        0.0242             nan     0.0100    0.0003
##     60        0.0189             nan     0.0100    0.0002
##     80        0.0148             nan     0.0100    0.0002
##    100        0.0116             nan     0.0100    0.0001
##    120        0.0091             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0001
##    160        0.0059             nan     0.0100    0.0001
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0005
##      2        0.0426             nan     0.0100    0.0008
##      3        0.0421             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100    0.0005
##      5        0.0411             nan     0.0100    0.0004
##      6        0.0406             nan     0.0100    0.0004
##      7        0.0398             nan     0.0100    0.0006
##      8        0.0395             nan     0.0100    0.0000
##      9        0.0388             nan     0.0100    0.0007
##     10        0.0381             nan     0.0100    0.0005
##     20        0.0333             nan     0.0100    0.0005
##     40        0.0257             nan     0.0100    0.0000
##     60        0.0198             nan     0.0100    0.0002
##     80        0.0154             nan     0.0100    0.0001
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100   -0.0000
##    140        0.0078             nan     0.0100   -0.0000
##    160        0.0064             nan     0.0100    0.0000
##    180        0.0052             nan     0.0100    0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0004
##      2        0.0429             nan     0.0100    0.0006
##      3        0.0425             nan     0.0100    0.0003
##      4        0.0422             nan     0.0100    0.0001
##      5        0.0416             nan     0.0100    0.0005
##      6        0.0412             nan     0.0100    0.0003
##      7        0.0407             nan     0.0100    0.0003
##      8        0.0401             nan     0.0100    0.0005
##      9        0.0396             nan     0.0100    0.0005
##     10        0.0391             nan     0.0100    0.0005
##     20        0.0350             nan     0.0100    0.0004
##     40        0.0284             nan     0.0100    0.0003
##     60        0.0229             nan     0.0100    0.0002
##     80        0.0191             nan     0.0100    0.0002
##    100        0.0161             nan     0.0100    0.0002
##    120        0.0137             nan     0.0100   -0.0000
##    140        0.0115             nan     0.0100   -0.0000
##    160        0.0099             nan     0.0100    0.0000
##    180        0.0088             nan     0.0100   -0.0001
##    200        0.0078             nan     0.0100    0.0001
## 
## - Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0006
##      2        0.0427             nan     0.0100    0.0004
##      3        0.0420             nan     0.0100    0.0006
##      4        0.0412             nan     0.0100    0.0006
##      5        0.0404             nan     0.0100    0.0008
##      6        0.0397             nan     0.0100    0.0007
##      7        0.0391             nan     0.0100    0.0004
##      8        0.0384             nan     0.0100    0.0006
##      9        0.0378             nan     0.0100    0.0006
##     10        0.0373             nan     0.0100    0.0005
##     20        0.0319             nan     0.0100    0.0004
##     40        0.0240             nan     0.0100    0.0004
##     60        0.0180             nan     0.0100   -0.0000
##     80        0.0141             nan     0.0100    0.0002
##    100        0.0113             nan     0.0100    0.0000
##    120        0.0086             nan     0.0100    0.0001
##    140        0.0066             nan     0.0100    0.0001
##    160        0.0052             nan     0.0100    0.0000
##    180        0.0042             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0008
##      2        0.0427             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0005
##      4        0.0415             nan     0.0100    0.0003
##      5        0.0409             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0002
##      7        0.0399             nan     0.0100    0.0006
##      8        0.0393             nan     0.0100    0.0006
##      9        0.0386             nan     0.0100    0.0005
##     10        0.0381             nan     0.0100    0.0005
##     20        0.0330             nan     0.0100    0.0004
##     40        0.0256             nan     0.0100    0.0003
##     60        0.0191             nan     0.0100    0.0003
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0120             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0000
##    160        0.0065             nan     0.0100    0.0000
##    180        0.0053             nan     0.0100    0.0001
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0006
##      2        0.0428             nan     0.0100    0.0004
##      3        0.0423             nan     0.0100    0.0003
##      4        0.0417             nan     0.0100    0.0004
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0410             nan     0.0100    0.0001
##      7        0.0405             nan     0.0100    0.0004
##      8        0.0400             nan     0.0100    0.0005
##      9        0.0399             nan     0.0100   -0.0002
##     10        0.0393             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0003
##     40        0.0275             nan     0.0100    0.0003
##     60        0.0225             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0002
##    100        0.0158             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100    0.0001
##    140        0.0115             nan     0.0100    0.0001
##    160        0.0102             nan     0.0100   -0.0000
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0025
##      2        0.0390             nan     0.0500    0.0026
##      3        0.0370             nan     0.0500    0.0020
##      4        0.0359             nan     0.0500   -0.0004
##      5        0.0329             nan     0.0500    0.0023
##      6        0.0305             nan     0.0500    0.0016
##      7        0.0287             nan     0.0500    0.0015
##      8        0.0266             nan     0.0500    0.0012
##      9        0.0251             nan     0.0500    0.0015
##     10        0.0236             nan     0.0500    0.0016
##     20        0.0142             nan     0.0500    0.0002
##     40        0.0058             nan     0.0500    0.0002
##     60        0.0027             nan     0.0500    0.0000
##     80        0.0014             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0030
##      2        0.0381             nan     0.0500    0.0025
##      3        0.0362             nan     0.0500    0.0016
##      4        0.0336             nan     0.0500    0.0022
##      5        0.0312             nan     0.0500    0.0018
##      6        0.0303             nan     0.0500    0.0005
##      7        0.0285             nan     0.0500    0.0016
##      8        0.0267             nan     0.0500    0.0018
##      9        0.0250             nan     0.0500    0.0016
##     10        0.0236             nan     0.0500    0.0010
##     20        0.0140             nan     0.0500    0.0007
##     40        0.0057             nan     0.0500    0.0003
##     60        0.0030             nan     0.0500    0.0001
##     80        0.0016             nan     0.0500   -0.0001
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0420             nan     0.0500    0.0026
##      2        0.0385             nan     0.0500    0.0027
##      3        0.0372             nan     0.0500    0.0005
##      4        0.0361             nan     0.0500    0.0004
##      5        0.0347             nan     0.0500    0.0010
##      6        0.0333             nan     0.0500    0.0014
##      7        0.0325             nan     0.0500    0.0001
##      8        0.0305             nan     0.0500    0.0010
##      9        0.0291             nan     0.0500    0.0010
##     10        0.0276             nan     0.0500    0.0008
##     20        0.0177             nan     0.0500    0.0001
##     40        0.0081             nan     0.0500   -0.0001
##     60        0.0044             nan     0.0500   -0.0001
##     80        0.0030             nan     0.0500   -0.0001
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0034
##      2        0.0378             nan     0.0500    0.0013
##      3        0.0352             nan     0.0500    0.0021
##      4        0.0329             nan     0.0500    0.0016
##      5        0.0307             nan     0.0500    0.0016
##      6        0.0284             nan     0.0500    0.0021
##      7        0.0274             nan     0.0500    0.0007
##      8        0.0251             nan     0.0500    0.0017
##      9        0.0235             nan     0.0500    0.0013
##     10        0.0223             nan     0.0500    0.0003
##     20        0.0117             nan     0.0500    0.0007
##     40        0.0039             nan     0.0500    0.0001
##     60        0.0017             nan     0.0500   -0.0000
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0422             nan     0.0500    0.0011
##      2        0.0390             nan     0.0500    0.0025
##      3        0.0376             nan     0.0500    0.0010
##      4        0.0353             nan     0.0500    0.0022
##      5        0.0326             nan     0.0500    0.0028
##      6        0.0300             nan     0.0500    0.0021
##      7        0.0281             nan     0.0500    0.0020
##      8        0.0255             nan     0.0500    0.0014
##      9        0.0234             nan     0.0500    0.0012
##     10        0.0224             nan     0.0500    0.0003
##     20        0.0121             nan     0.0500    0.0005
##     40        0.0042             nan     0.0500   -0.0000
##     60        0.0021             nan     0.0500   -0.0000
##     80        0.0012             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0028
##      2        0.0385             nan     0.0500    0.0014
##      3        0.0365             nan     0.0500    0.0020
##      4        0.0346             nan     0.0500    0.0009
##      5        0.0320             nan     0.0500    0.0013
##      6        0.0301             nan     0.0500    0.0010
##      7        0.0286             nan     0.0500    0.0006
##      8        0.0270             nan     0.0500    0.0009
##      9        0.0251             nan     0.0500    0.0015
##     10        0.0245             nan     0.0500    0.0000
##     20        0.0159             nan     0.0500    0.0007
##     40        0.0088             nan     0.0500    0.0000
##     60        0.0052             nan     0.0500    0.0001
##     80        0.0039             nan     0.0500   -0.0000
##    100        0.0027             nan     0.0500    0.0000
##    120        0.0018             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0027
##      2        0.0391             nan     0.0500    0.0010
##      3        0.0376             nan     0.0500    0.0010
##      4        0.0347             nan     0.0500    0.0020
##      5        0.0329             nan     0.0500    0.0022
##      6        0.0305             nan     0.0500    0.0021
##      7        0.0278             nan     0.0500    0.0013
##      8        0.0254             nan     0.0500    0.0016
##      9        0.0234             nan     0.0500    0.0015
##     10        0.0220             nan     0.0500    0.0001
##     20        0.0108             nan     0.0500    0.0007
##     40        0.0033             nan     0.0500   -0.0000
##     60        0.0012             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0021
##      2        0.0382             nan     0.0500    0.0024
##      3        0.0350             nan     0.0500    0.0015
##      4        0.0323             nan     0.0500    0.0028
##      5        0.0307             nan     0.0500    0.0005
##      6        0.0298             nan     0.0500   -0.0005
##      7        0.0277             nan     0.0500    0.0022
##      8        0.0257             nan     0.0500    0.0014
##      9        0.0239             nan     0.0500    0.0016
##     10        0.0220             nan     0.0500    0.0019
##     20        0.0124             nan     0.0500    0.0003
##     40        0.0046             nan     0.0500   -0.0002
##     60        0.0023             nan     0.0500    0.0001
##     80        0.0013             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0025
##      2        0.0398             nan     0.0500    0.0019
##      3        0.0371             nan     0.0500    0.0017
##      4        0.0345             nan     0.0500    0.0024
##      5        0.0323             nan     0.0500    0.0006
##      6        0.0307             nan     0.0500    0.0015
##      7        0.0293             nan     0.0500    0.0011
##      8        0.0275             nan     0.0500    0.0019
##      9        0.0256             nan     0.0500    0.0016
##     10        0.0248             nan     0.0500    0.0005
##     20        0.0149             nan     0.0500    0.0006
##     40        0.0075             nan     0.0500    0.0001
##     60        0.0039             nan     0.0500   -0.0000
##     80        0.0024             nan     0.0500   -0.0000
##    100        0.0016             nan     0.0500    0.0000
##    120        0.0011             nan     0.0500   -0.0000
##    140        0.0007             nan     0.0500   -0.0000
##    160        0.0005             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.1000   -0.0022
##      2        0.0380             nan     0.1000    0.0027
##      3        0.0340             nan     0.1000    0.0042
##      4        0.0317             nan     0.1000    0.0013
##      5        0.0279             nan     0.1000    0.0032
##      6        0.0241             nan     0.1000    0.0033
##      7        0.0224             nan     0.1000    0.0001
##      8        0.0204             nan     0.1000    0.0013
##      9        0.0188             nan     0.1000    0.0021
##     10        0.0170             nan     0.1000    0.0007
##     20        0.0061             nan     0.1000    0.0009
##     40        0.0014             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0045
##      2        0.0316             nan     0.1000    0.0046
##      3        0.0289             nan     0.1000   -0.0003
##      4        0.0271             nan     0.1000    0.0014
##      5        0.0245             nan     0.1000    0.0020
##      6        0.0233             nan     0.1000    0.0011
##      7        0.0214             nan     0.1000    0.0020
##      8        0.0188             nan     0.1000    0.0012
##      9        0.0166             nan     0.1000    0.0011
##     10        0.0152             nan     0.1000   -0.0005
##     20        0.0073             nan     0.1000   -0.0002
##     40        0.0027             nan     0.1000   -0.0000
##     60        0.0010             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0057
##      2        0.0358             nan     0.1000   -0.0006
##      3        0.0335             nan     0.1000    0.0024
##      4        0.0306             nan     0.1000    0.0020
##      5        0.0281             nan     0.1000    0.0032
##      6        0.0256             nan     0.1000    0.0011
##      7        0.0239             nan     0.1000    0.0011
##      8        0.0216             nan     0.1000    0.0019
##      9        0.0200             nan     0.1000    0.0011
##     10        0.0180             nan     0.1000    0.0019
##     20        0.0093             nan     0.1000    0.0005
##     40        0.0035             nan     0.1000   -0.0002
##     60        0.0020             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.1000    0.0076
##      2        0.0324             nan     0.1000    0.0020
##      3        0.0264             nan     0.1000    0.0049
##      4        0.0241             nan     0.1000    0.0024
##      5        0.0217             nan     0.1000    0.0022
##      6        0.0189             nan     0.1000    0.0010
##      7        0.0166             nan     0.1000    0.0022
##      8        0.0146             nan     0.1000    0.0011
##      9        0.0133             nan     0.1000    0.0007
##     10        0.0113             nan     0.1000    0.0013
##     20        0.0035             nan     0.1000    0.0001
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0066
##      2        0.0314             nan     0.1000    0.0047
##      3        0.0269             nan     0.1000    0.0025
##      4        0.0240             nan     0.1000    0.0024
##      5        0.0220             nan     0.1000    0.0001
##      6        0.0193             nan     0.1000    0.0028
##      7        0.0162             nan     0.1000    0.0022
##      8        0.0145             nan     0.1000    0.0010
##      9        0.0127             nan     0.1000    0.0010
##     10        0.0107             nan     0.1000    0.0009
##     20        0.0046             nan     0.1000    0.0005
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.1000    0.0017
##      2        0.0360             nan     0.1000    0.0053
##      3        0.0314             nan     0.1000    0.0033
##      4        0.0281             nan     0.1000    0.0005
##      5        0.0250             nan     0.1000    0.0031
##      6        0.0220             nan     0.1000    0.0026
##      7        0.0201             nan     0.1000    0.0024
##      8        0.0182             nan     0.1000    0.0021
##      9        0.0164             nan     0.1000    0.0019
##     10        0.0160             nan     0.1000   -0.0007
##     20        0.0079             nan     0.1000    0.0005
##     40        0.0028             nan     0.1000   -0.0002
##     60        0.0014             nan     0.1000   -0.0001
##     80        0.0006             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0025
##      2        0.0331             nan     0.1000    0.0042
##      3        0.0275             nan     0.1000    0.0034
##      4        0.0251             nan     0.1000    0.0015
##      5        0.0224             nan     0.1000    0.0025
##      6        0.0194             nan     0.1000    0.0027
##      7        0.0173             nan     0.1000    0.0010
##      8        0.0153             nan     0.1000    0.0010
##      9        0.0137             nan     0.1000    0.0014
##     10        0.0125             nan     0.1000    0.0015
##     20        0.0041             nan     0.1000   -0.0001
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.1000    0.0059
##      2        0.0313             nan     0.1000    0.0020
##      3        0.0271             nan     0.1000    0.0047
##      4        0.0247             nan     0.1000    0.0027
##      5        0.0223             nan     0.1000    0.0023
##      6        0.0195             nan     0.1000    0.0028
##      7        0.0175             nan     0.1000    0.0017
##      8        0.0161             nan     0.1000    0.0003
##      9        0.0136             nan     0.1000    0.0007
##     10        0.0122             nan     0.1000    0.0016
##     20        0.0041             nan     0.1000    0.0002
##     40        0.0010             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.1000    0.0051
##      2        0.0342             nan     0.1000    0.0046
##      3        0.0310             nan     0.1000    0.0029
##      4        0.0283             nan     0.1000    0.0019
##      5        0.0251             nan     0.1000    0.0022
##      6        0.0229             nan     0.1000    0.0027
##      7        0.0210             nan     0.1000    0.0011
##      8        0.0193             nan     0.1000    0.0019
##      9        0.0181             nan     0.1000    0.0016
##     10        0.0169             nan     0.1000    0.0009
##     20        0.0090             nan     0.1000   -0.0000
##     40        0.0035             nan     0.1000    0.0001
##     60        0.0018             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0432             nan     0.0100    0.0004
##      3        0.0426             nan     0.0100    0.0005
##      4        0.0419             nan     0.0100    0.0006
##      5        0.0415             nan     0.0100    0.0004
##      6        0.0410             nan     0.0100    0.0004
##      7        0.0404             nan     0.0100    0.0006
##      8        0.0398             nan     0.0100    0.0006
##      9        0.0393             nan     0.0100    0.0006
##     10        0.0388             nan     0.0100    0.0003
##     20        0.0351             nan     0.0100    0.0004
##     40        0.0275             nan     0.0100    0.0000
##     60        0.0223             nan     0.0100    0.0001
##     80        0.0181             nan     0.0100    0.0002
##    100        0.0151             nan     0.0100    0.0001
##    120        0.0126             nan     0.0100    0.0001
##    140        0.0104             nan     0.0100    0.0002
##    160        0.0087             nan     0.0100    0.0001
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0064             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0007
##      2        0.0431             nan     0.0100    0.0006
##      3        0.0426             nan     0.0100    0.0006
##      4        0.0422             nan     0.0100    0.0004
##      5        0.0417             nan     0.0100    0.0005
##      6        0.0414             nan     0.0100    0.0000
##      7        0.0412             nan     0.0100   -0.0000
##      8        0.0406             nan     0.0100    0.0005
##      9        0.0400             nan     0.0100    0.0005
##     10        0.0395             nan     0.0100    0.0005
##     20        0.0349             nan     0.0100    0.0004
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0186             nan     0.0100    0.0002
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0127             nan     0.0100    0.0001
##    140        0.0106             nan     0.0100    0.0001
##    160        0.0090             nan     0.0100    0.0000
##    180        0.0077             nan     0.0100    0.0001
##    200        0.0066             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0431             nan     0.0100    0.0006
##      3        0.0425             nan     0.0100    0.0006
##      4        0.0422             nan     0.0100    0.0003
##      5        0.0416             nan     0.0100    0.0006
##      6        0.0410             nan     0.0100    0.0006
##      7        0.0404             nan     0.0100    0.0002
##      8        0.0399             nan     0.0100    0.0006
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0003
##     20        0.0350             nan     0.0100    0.0004
##     40        0.0283             nan     0.0100    0.0003
##     60        0.0227             nan     0.0100    0.0001
##     80        0.0191             nan     0.0100   -0.0000
##    100        0.0159             nan     0.0100    0.0001
##    120        0.0137             nan     0.0100    0.0001
##    140        0.0115             nan     0.0100    0.0000
##    160        0.0102             nan     0.0100    0.0000
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0004
##      2        0.0430             nan     0.0100    0.0005
##      3        0.0425             nan     0.0100    0.0002
##      4        0.0422             nan     0.0100   -0.0000
##      5        0.0416             nan     0.0100    0.0007
##      6        0.0410             nan     0.0100    0.0004
##      7        0.0404             nan     0.0100    0.0004
##      8        0.0397             nan     0.0100    0.0007
##      9        0.0392             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100    0.0002
##     20        0.0342             nan     0.0100    0.0001
##     40        0.0264             nan     0.0100    0.0005
##     60        0.0206             nan     0.0100    0.0002
##     80        0.0158             nan     0.0100    0.0000
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0077             nan     0.0100    0.0000
##    160        0.0062             nan     0.0100    0.0001
##    180        0.0050             nan     0.0100   -0.0000
##    200        0.0040             nan     0.0100    0.0001
## 
## - Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0441             nan     0.0100    0.0001
##      2        0.0434             nan     0.0100    0.0003
##      3        0.0428             nan     0.0100    0.0004
##      4        0.0421             nan     0.0100    0.0007
##      5        0.0417             nan     0.0100    0.0002
##      6        0.0411             nan     0.0100    0.0005
##      7        0.0404             nan     0.0100    0.0006
##      8        0.0400             nan     0.0100    0.0004
##      9        0.0393             nan     0.0100    0.0006
##     10        0.0389             nan     0.0100    0.0003
##     20        0.0342             nan     0.0100    0.0005
##     40        0.0263             nan     0.0100    0.0004
##     60        0.0202             nan     0.0100    0.0002
##     80        0.0156             nan     0.0100    0.0000
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0098             nan     0.0100    0.0001
##    140        0.0078             nan     0.0100    0.0001
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0051             nan     0.0100    0.0000
##    200        0.0042             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0443             nan     0.0100   -0.0001
##      2        0.0438             nan     0.0100    0.0005
##      3        0.0431             nan     0.0100    0.0005
##      4        0.0425             nan     0.0100    0.0003
##      5        0.0418             nan     0.0100    0.0005
##      6        0.0412             nan     0.0100    0.0005
##      7        0.0408             nan     0.0100    0.0004
##      8        0.0402             nan     0.0100    0.0005
##      9        0.0399             nan     0.0100    0.0001
##     10        0.0395             nan     0.0100    0.0003
##     20        0.0350             nan     0.0100    0.0003
##     40        0.0278             nan     0.0100    0.0003
##     60        0.0222             nan     0.0100    0.0002
##     80        0.0182             nan     0.0100    0.0000
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100    0.0000
##    140        0.0114             nan     0.0100    0.0000
##    160        0.0100             nan     0.0100    0.0000
##    180        0.0088             nan     0.0100    0.0000
##    200        0.0078             nan     0.0100   -0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0006
##      3        0.0420             nan     0.0100    0.0006
##      4        0.0415             nan     0.0100    0.0002
##      5        0.0410             nan     0.0100    0.0002
##      6        0.0404             nan     0.0100    0.0005
##      7        0.0399             nan     0.0100    0.0004
##      8        0.0392             nan     0.0100    0.0006
##      9        0.0384             nan     0.0100    0.0007
##     10        0.0381             nan     0.0100    0.0002
##     20        0.0329             nan     0.0100    0.0004
##     40        0.0246             nan     0.0100    0.0004
##     60        0.0188             nan     0.0100    0.0001
##     80        0.0143             nan     0.0100    0.0001
##    100        0.0110             nan     0.0100    0.0001
##    120        0.0085             nan     0.0100    0.0001
##    140        0.0065             nan     0.0100    0.0000
##    160        0.0053             nan     0.0100    0.0001
##    180        0.0041             nan     0.0100    0.0000
##    200        0.0034             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0002
##      2        0.0432             nan     0.0100    0.0006
##      3        0.0424             nan     0.0100    0.0007
##      4        0.0419             nan     0.0100    0.0006
##      5        0.0413             nan     0.0100    0.0006
##      6        0.0406             nan     0.0100    0.0005
##      7        0.0402             nan     0.0100    0.0002
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0390             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0003
##     20        0.0327             nan     0.0100    0.0005
##     40        0.0244             nan     0.0100    0.0001
##     60        0.0190             nan     0.0100    0.0001
##     80        0.0148             nan     0.0100    0.0001
##    100        0.0116             nan     0.0100    0.0000
##    120        0.0089             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0000
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100   -0.0000
##    200        0.0038             nan     0.0100    0.0001
## 
## - Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0440             nan     0.0100    0.0005
##      2        0.0434             nan     0.0100    0.0006
##      3        0.0430             nan     0.0100    0.0001
##      4        0.0427             nan     0.0100   -0.0002
##      5        0.0421             nan     0.0100    0.0005
##      6        0.0418             nan     0.0100    0.0003
##      7        0.0412             nan     0.0100    0.0006
##      8        0.0406             nan     0.0100    0.0006
##      9        0.0401             nan     0.0100    0.0005
##     10        0.0394             nan     0.0100    0.0006
##     20        0.0353             nan     0.0100    0.0001
##     40        0.0285             nan     0.0100    0.0004
##     60        0.0237             nan     0.0100    0.0003
##     80        0.0193             nan     0.0100    0.0002
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0108             nan     0.0100    0.0000
##    180        0.0095             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0419             nan     0.0500    0.0026
##      2        0.0390             nan     0.0500    0.0027
##      3        0.0369             nan     0.0500    0.0016
##      4        0.0341             nan     0.0500    0.0020
##      5        0.0319             nan     0.0500    0.0019
##      6        0.0299             nan     0.0500    0.0018
##      7        0.0277             nan     0.0500    0.0014
##      8        0.0270             nan     0.0500    0.0003
##      9        0.0254             nan     0.0500    0.0013
##     10        0.0245             nan     0.0500   -0.0003
##     20        0.0149             nan     0.0500    0.0006
##     40        0.0065             nan     0.0500    0.0001
##     60        0.0028             nan     0.0500    0.0000
##     80        0.0015             nan     0.0500   -0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0028
##      2        0.0411             nan     0.0500   -0.0013
##      3        0.0389             nan     0.0500    0.0023
##      4        0.0364             nan     0.0500    0.0016
##      5        0.0352             nan     0.0500    0.0007
##      6        0.0334             nan     0.0500   -0.0000
##      7        0.0312             nan     0.0500    0.0022
##      8        0.0299             nan     0.0500   -0.0002
##      9        0.0274             nan     0.0500    0.0018
##     10        0.0266             nan     0.0500    0.0001
##     20        0.0153             nan     0.0500    0.0009
##     40        0.0060             nan     0.0500    0.0002
##     60        0.0033             nan     0.0500    0.0001
##     80        0.0019             nan     0.0500   -0.0000
##    100        0.0011             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0024
##      2        0.0389             nan     0.0500    0.0021
##      3        0.0367             nan     0.0500    0.0022
##      4        0.0346             nan     0.0500    0.0021
##      5        0.0328             nan     0.0500    0.0010
##      6        0.0308             nan     0.0500    0.0010
##      7        0.0297             nan     0.0500    0.0009
##      8        0.0285             nan     0.0500    0.0007
##      9        0.0270             nan     0.0500    0.0008
##     10        0.0254             nan     0.0500    0.0015
##     20        0.0158             nan     0.0500    0.0002
##     40        0.0080             nan     0.0500    0.0002
##     60        0.0047             nan     0.0500    0.0000
##     80        0.0028             nan     0.0500    0.0000
##    100        0.0020             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0031
##      2        0.0392             nan     0.0500    0.0020
##      3        0.0366             nan     0.0500    0.0018
##      4        0.0336             nan     0.0500    0.0024
##      5        0.0315             nan     0.0500    0.0008
##      6        0.0299             nan     0.0500    0.0007
##      7        0.0282             nan     0.0500    0.0013
##      8        0.0265             nan     0.0500    0.0005
##      9        0.0245             nan     0.0500    0.0019
##     10        0.0228             nan     0.0500    0.0018
##     20        0.0119             nan     0.0500   -0.0002
##     40        0.0045             nan     0.0500   -0.0001
##     60        0.0015             nan     0.0500   -0.0001
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0032
##      2        0.0383             nan     0.0500    0.0021
##      3        0.0355             nan     0.0500    0.0029
##      4        0.0327             nan     0.0500    0.0029
##      5        0.0310             nan     0.0500    0.0019
##      6        0.0289             nan     0.0500    0.0017
##      7        0.0269             nan     0.0500    0.0018
##      8        0.0255             nan     0.0500    0.0016
##      9        0.0234             nan     0.0500    0.0016
##     10        0.0214             nan     0.0500    0.0019
##     20        0.0123             nan     0.0500    0.0003
##     40        0.0045             nan     0.0500   -0.0000
##     60        0.0023             nan     0.0500    0.0000
##     80        0.0012             nan     0.0500    0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0026
##      2        0.0385             nan     0.0500    0.0013
##      3        0.0364             nan     0.0500    0.0013
##      4        0.0340             nan     0.0500    0.0024
##      5        0.0319             nan     0.0500    0.0019
##      6        0.0301             nan     0.0500    0.0017
##      7        0.0285             nan     0.0500    0.0018
##      8        0.0267             nan     0.0500    0.0013
##      9        0.0248             nan     0.0500    0.0017
##     10        0.0233             nan     0.0500    0.0015
##     20        0.0145             nan     0.0500    0.0004
##     40        0.0075             nan     0.0500   -0.0000
##     60        0.0040             nan     0.0500   -0.0001
##     80        0.0027             nan     0.0500   -0.0000
##    100        0.0019             nan     0.0500   -0.0000
##    120        0.0013             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0030
##      2        0.0376             nan     0.0500    0.0040
##      3        0.0354             nan     0.0500    0.0023
##      4        0.0325             nan     0.0500    0.0018
##      5        0.0301             nan     0.0500    0.0024
##      6        0.0287             nan     0.0500    0.0011
##      7        0.0264             nan     0.0500    0.0011
##      8        0.0240             nan     0.0500    0.0023
##      9        0.0231             nan     0.0500    0.0008
##     10        0.0221             nan     0.0500    0.0010
##     20        0.0124             nan     0.0500    0.0004
##     40        0.0037             nan     0.0500    0.0001
##     60        0.0013             nan     0.0500    0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0500    0.0020
##      2        0.0389             nan     0.0500    0.0034
##      3        0.0359             nan     0.0500    0.0028
##      4        0.0332             nan     0.0500    0.0024
##      5        0.0296             nan     0.0500    0.0027
##      6        0.0278             nan     0.0500    0.0016
##      7        0.0258             nan     0.0500    0.0005
##      8        0.0242             nan     0.0500    0.0018
##      9        0.0226             nan     0.0500    0.0016
##     10        0.0216             nan     0.0500    0.0004
##     20        0.0108             nan     0.0500    0.0005
##     40        0.0041             nan     0.0500    0.0001
##     60        0.0019             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0500    0.0003
##      2        0.0395             nan     0.0500    0.0027
##      3        0.0371             nan     0.0500    0.0018
##      4        0.0346             nan     0.0500    0.0024
##      5        0.0329             nan     0.0500    0.0008
##      6        0.0318             nan     0.0500   -0.0001
##      7        0.0300             nan     0.0500    0.0004
##      8        0.0278             nan     0.0500    0.0016
##      9        0.0262             nan     0.0500    0.0015
##     10        0.0248             nan     0.0500    0.0007
##     20        0.0162             nan     0.0500    0.0002
##     40        0.0077             nan     0.0500    0.0002
##     60        0.0044             nan     0.0500    0.0000
##     80        0.0029             nan     0.0500   -0.0001
##    100        0.0020             nan     0.0500   -0.0001
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.1000    0.0035
##      2        0.0348             nan     0.1000    0.0048
##      3        0.0309             nan     0.1000    0.0044
##      4        0.0287             nan     0.1000    0.0023
##      5        0.0253             nan     0.1000    0.0031
##      6        0.0223             nan     0.1000    0.0027
##      7        0.0208             nan     0.1000    0.0009
##      8        0.0184             nan     0.1000    0.0014
##      9        0.0174             nan     0.1000    0.0003
##     10        0.0159             nan     0.1000    0.0008
##     20        0.0064             nan     0.1000    0.0002
##     40        0.0017             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0052
##      2        0.0332             nan     0.1000    0.0048
##      3        0.0297             nan     0.1000    0.0030
##      4        0.0265             nan     0.1000    0.0035
##      5        0.0256             nan     0.1000   -0.0003
##      6        0.0229             nan     0.1000    0.0011
##      7        0.0198             nan     0.1000    0.0010
##      8        0.0180             nan     0.1000    0.0021
##      9        0.0160             nan     0.1000    0.0014
##     10        0.0151             nan     0.1000    0.0004
##     20        0.0083             nan     0.1000    0.0005
##     40        0.0025             nan     0.1000   -0.0001
##     60        0.0010             nan     0.1000   -0.0001
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0061
##      2        0.0332             nan     0.1000    0.0029
##      3        0.0300             nan     0.1000    0.0030
##      4        0.0272             nan     0.1000   -0.0002
##      5        0.0238             nan     0.1000    0.0027
##      6        0.0220             nan     0.1000    0.0015
##      7        0.0200             nan     0.1000    0.0021
##      8        0.0173             nan     0.1000    0.0019
##      9        0.0153             nan     0.1000    0.0009
##     10        0.0132             nan     0.1000    0.0012
##     20        0.0076             nan     0.1000   -0.0002
##     40        0.0026             nan     0.1000    0.0000
##     60        0.0012             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.1000    0.0077
##      2        0.0315             nan     0.1000    0.0049
##      3        0.0267             nan     0.1000    0.0054
##      4        0.0260             nan     0.1000   -0.0017
##      5        0.0222             nan     0.1000    0.0028
##      6        0.0189             nan     0.1000    0.0026
##      7        0.0165             nan     0.1000    0.0013
##      8        0.0144             nan     0.1000    0.0020
##      9        0.0127             nan     0.1000    0.0014
##     10        0.0108             nan     0.1000    0.0010
##     20        0.0042             nan     0.1000   -0.0001
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000    0.0022
##      2        0.0361             nan     0.1000    0.0015
##      3        0.0303             nan     0.1000    0.0047
##      4        0.0246             nan     0.1000    0.0036
##      5        0.0211             nan     0.1000    0.0035
##      6        0.0184             nan     0.1000    0.0015
##      7        0.0168             nan     0.1000    0.0017
##      8        0.0141             nan     0.1000    0.0019
##      9        0.0123             nan     0.1000    0.0016
##     10        0.0109             nan     0.1000    0.0001
##     20        0.0041             nan     0.1000    0.0002
##     40        0.0009             nan     0.1000    0.0001
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0389             nan     0.1000    0.0037
##      2        0.0333             nan     0.1000    0.0054
##      3        0.0277             nan     0.1000    0.0038
##      4        0.0251             nan     0.1000    0.0030
##      5        0.0230             nan     0.1000    0.0019
##      6        0.0204             nan     0.1000    0.0018
##      7        0.0186             nan     0.1000   -0.0008
##      8        0.0171             nan     0.1000    0.0016
##      9        0.0162             nan     0.1000    0.0003
##     10        0.0150             nan     0.1000    0.0014
##     20        0.0072             nan     0.1000    0.0002
##     40        0.0029             nan     0.1000   -0.0000
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0362             nan     0.1000    0.0078
##      2        0.0313             nan     0.1000    0.0045
##      3        0.0260             nan     0.1000    0.0052
##      4        0.0225             nan     0.1000    0.0028
##      5        0.0193             nan     0.1000    0.0018
##      6        0.0173             nan     0.1000    0.0009
##      7        0.0152             nan     0.1000    0.0013
##      8        0.0134             nan     0.1000    0.0008
##      9        0.0111             nan     0.1000    0.0016
##     10        0.0102             nan     0.1000    0.0001
##     20        0.0037             nan     0.1000   -0.0000
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.1000    0.0038
##      2        0.0343             nan     0.1000    0.0043
##      3        0.0291             nan     0.1000    0.0046
##      4        0.0264             nan     0.1000    0.0010
##      5        0.0240             nan     0.1000    0.0004
##      6        0.0195             nan     0.1000    0.0029
##      7        0.0170             nan     0.1000   -0.0002
##      8        0.0155             nan     0.1000    0.0010
##      9        0.0137             nan     0.1000    0.0012
##     10        0.0122             nan     0.1000    0.0011
##     20        0.0041             nan     0.1000    0.0003
##     40        0.0012             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0053
##      2        0.0339             nan     0.1000    0.0044
##      3        0.0304             nan     0.1000    0.0013
##      4        0.0280             nan     0.1000    0.0018
##      5        0.0258             nan     0.1000    0.0026
##      6        0.0232             nan     0.1000    0.0029
##      7        0.0207             nan     0.1000    0.0023
##      8        0.0187             nan     0.1000    0.0010
##      9        0.0172             nan     0.1000    0.0016
##     10        0.0159             nan     0.1000    0.0012
##     20        0.0076             nan     0.1000    0.0000
##     40        0.0027             nan     0.1000    0.0000
##     60        0.0013             nan     0.1000   -0.0001
##     80        0.0007             nan     0.1000    0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0002
##      2        0.0426             nan     0.0100    0.0001
##      3        0.0423             nan     0.0100    0.0002
##      4        0.0419             nan     0.0100    0.0001
##      5        0.0415             nan     0.0100    0.0002
##      6        0.0409             nan     0.0100    0.0005
##      7        0.0405             nan     0.0100    0.0004
##      8        0.0399             nan     0.0100    0.0006
##      9        0.0395             nan     0.0100    0.0004
##     10        0.0388             nan     0.0100    0.0004
##     20        0.0345             nan     0.0100    0.0003
##     40        0.0271             nan     0.0100    0.0003
##     60        0.0222             nan     0.0100    0.0003
##     80        0.0179             nan     0.0100    0.0002
##    100        0.0147             nan     0.0100    0.0000
##    120        0.0120             nan     0.0100    0.0001
##    140        0.0098             nan     0.0100    0.0000
##    160        0.0084             nan     0.0100    0.0000
##    180        0.0069             nan     0.0100   -0.0000
##    200        0.0057             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0100    0.0002
##      2        0.0427             nan     0.0100    0.0004
##      3        0.0422             nan     0.0100    0.0002
##      4        0.0417             nan     0.0100    0.0005
##      5        0.0414             nan     0.0100    0.0003
##      6        0.0407             nan     0.0100    0.0004
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0397             nan     0.0100    0.0005
##      9        0.0391             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100    0.0003
##     20        0.0342             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100    0.0003
##     60        0.0217             nan     0.0100    0.0002
##     80        0.0177             nan     0.0100    0.0000
##    100        0.0149             nan     0.0100    0.0001
##    120        0.0124             nan     0.0100    0.0001
##    140        0.0106             nan     0.0100    0.0000
##    160        0.0091             nan     0.0100   -0.0000
##    180        0.0077             nan     0.0100    0.0001
##    200        0.0067             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0006
##      2        0.0424             nan     0.0100    0.0005
##      3        0.0423             nan     0.0100   -0.0000
##      4        0.0417             nan     0.0100    0.0003
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0006
##      7        0.0401             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0005
##      9        0.0392             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0004
##     40        0.0270             nan     0.0100    0.0003
##     60        0.0220             nan     0.0100    0.0002
##     80        0.0185             nan     0.0100    0.0001
##    100        0.0157             nan     0.0100   -0.0000
##    120        0.0137             nan     0.0100   -0.0000
##    140        0.0117             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100   -0.0000
##    180        0.0091             nan     0.0100    0.0001
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0007
##      2        0.0422             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100   -0.0001
##      4        0.0411             nan     0.0100    0.0008
##      5        0.0404             nan     0.0100    0.0006
##      6        0.0398             nan     0.0100    0.0004
##      7        0.0391             nan     0.0100    0.0006
##      8        0.0388             nan     0.0100    0.0002
##      9        0.0384             nan     0.0100    0.0004
##     10        0.0380             nan     0.0100    0.0002
##     20        0.0332             nan     0.0100    0.0004
##     40        0.0248             nan     0.0100    0.0002
##     60        0.0187             nan     0.0100    0.0001
##     80        0.0147             nan     0.0100    0.0001
##    100        0.0113             nan     0.0100    0.0001
##    120        0.0090             nan     0.0100    0.0000
##    140        0.0071             nan     0.0100    0.0001
##    160        0.0056             nan     0.0100    0.0000
##    180        0.0044             nan     0.0100    0.0001
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0002
##      2        0.0427             nan     0.0100    0.0005
##      3        0.0424             nan     0.0100    0.0003
##      4        0.0420             nan     0.0100    0.0004
##      5        0.0417             nan     0.0100   -0.0000
##      6        0.0412             nan     0.0100    0.0004
##      7        0.0407             nan     0.0100    0.0004
##      8        0.0401             nan     0.0100    0.0007
##      9        0.0394             nan     0.0100    0.0004
##     10        0.0388             nan     0.0100    0.0004
##     20        0.0338             nan     0.0100    0.0001
##     40        0.0259             nan     0.0100    0.0003
##     60        0.0201             nan     0.0100    0.0002
##     80        0.0157             nan     0.0100    0.0002
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0100             nan     0.0100    0.0001
##    140        0.0081             nan     0.0100    0.0001
##    160        0.0065             nan     0.0100    0.0000
##    180        0.0055             nan     0.0100    0.0000
##    200        0.0045             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0001
##      2        0.0429             nan     0.0100    0.0003
##      3        0.0425             nan     0.0100    0.0003
##      4        0.0420             nan     0.0100    0.0005
##      5        0.0414             nan     0.0100    0.0005
##      6        0.0410             nan     0.0100    0.0004
##      7        0.0407             nan     0.0100    0.0001
##      8        0.0403             nan     0.0100    0.0001
##      9        0.0399             nan     0.0100    0.0004
##     10        0.0393             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0004
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0224             nan     0.0100    0.0003
##     80        0.0186             nan     0.0100    0.0001
##    100        0.0153             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100   -0.0001
##    140        0.0114             nan     0.0100    0.0001
##    160        0.0099             nan     0.0100    0.0000
##    180        0.0088             nan     0.0100    0.0000
##    200        0.0077             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0005
##      2        0.0424             nan     0.0100    0.0004
##      3        0.0417             nan     0.0100    0.0004
##      4        0.0410             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0002
##      6        0.0402             nan     0.0100    0.0002
##      7        0.0396             nan     0.0100    0.0004
##      8        0.0391             nan     0.0100    0.0004
##      9        0.0385             nan     0.0100    0.0005
##     10        0.0377             nan     0.0100    0.0006
##     20        0.0324             nan     0.0100    0.0004
##     40        0.0241             nan     0.0100    0.0002
##     60        0.0183             nan     0.0100    0.0002
##     80        0.0143             nan     0.0100    0.0000
##    100        0.0109             nan     0.0100    0.0001
##    120        0.0083             nan     0.0100    0.0001
##    140        0.0065             nan     0.0100    0.0001
##    160        0.0053             nan     0.0100    0.0000
##    180        0.0043             nan     0.0100    0.0000
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0100    0.0005
##      2        0.0425             nan     0.0100    0.0005
##      3        0.0419             nan     0.0100    0.0004
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0408             nan     0.0100    0.0002
##      6        0.0405             nan     0.0100    0.0003
##      7        0.0400             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100    0.0004
##      9        0.0388             nan     0.0100    0.0004
##     10        0.0384             nan     0.0100    0.0005
##     20        0.0337             nan     0.0100    0.0002
##     40        0.0259             nan     0.0100    0.0002
##     60        0.0199             nan     0.0100    0.0002
##     80        0.0152             nan     0.0100    0.0001
##    100        0.0120             nan     0.0100    0.0001
##    120        0.0096             nan     0.0100    0.0000
##    140        0.0077             nan     0.0100   -0.0001
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0428             nan     0.0100    0.0005
##      3        0.0423             nan     0.0100    0.0006
##      4        0.0418             nan     0.0100    0.0005
##      5        0.0415             nan     0.0100    0.0001
##      6        0.0411             nan     0.0100    0.0005
##      7        0.0407             nan     0.0100    0.0003
##      8        0.0402             nan     0.0100    0.0003
##      9        0.0398             nan     0.0100    0.0001
##     10        0.0391             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0005
##     40        0.0282             nan     0.0100   -0.0001
##     60        0.0230             nan     0.0100    0.0003
##     80        0.0193             nan     0.0100    0.0001
##    100        0.0160             nan     0.0100    0.0000
##    120        0.0134             nan     0.0100    0.0001
##    140        0.0111             nan     0.0100    0.0001
##    160        0.0097             nan     0.0100    0.0001
##    180        0.0086             nan     0.0100    0.0000
##    200        0.0077             nan     0.0100    0.0000
## 
## - Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0026
##      2        0.0383             nan     0.0500    0.0022
##      3        0.0359             nan     0.0500    0.0028
##      4        0.0342             nan     0.0500    0.0014
##      5        0.0313             nan     0.0500    0.0030
##      6        0.0306             nan     0.0500   -0.0004
##      7        0.0290             nan     0.0500    0.0018
##      8        0.0268             nan     0.0500    0.0013
##      9        0.0251             nan     0.0500    0.0017
##     10        0.0244             nan     0.0500    0.0008
##     20        0.0145             nan     0.0500    0.0007
##     40        0.0065             nan     0.0500    0.0000
##     60        0.0032             nan     0.0500    0.0001
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0016
##      2        0.0392             nan     0.0500    0.0009
##      3        0.0377             nan     0.0500    0.0013
##      4        0.0348             nan     0.0500    0.0025
##      5        0.0330             nan     0.0500    0.0022
##      6        0.0310             nan     0.0500    0.0021
##      7        0.0286             nan     0.0500    0.0019
##      8        0.0271             nan     0.0500    0.0001
##      9        0.0256             nan     0.0500    0.0014
##     10        0.0246             nan     0.0500    0.0001
##     20        0.0138             nan     0.0500    0.0009
##     40        0.0060             nan     0.0500    0.0002
##     60        0.0029             nan     0.0500   -0.0000
##     80        0.0016             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0030
##      2        0.0381             nan     0.0500    0.0028
##      3        0.0356             nan     0.0500    0.0023
##      4        0.0349             nan     0.0500   -0.0003
##      5        0.0331             nan     0.0500    0.0019
##      6        0.0316             nan     0.0500    0.0011
##      7        0.0303             nan     0.0500    0.0012
##      8        0.0285             nan     0.0500    0.0015
##      9        0.0276             nan     0.0500    0.0011
##     10        0.0261             nan     0.0500    0.0013
##     20        0.0171             nan     0.0500    0.0007
##     40        0.0078             nan     0.0500    0.0002
##     60        0.0047             nan     0.0500    0.0001
##     80        0.0031             nan     0.0500    0.0000
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500    0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0500    0.0035
##      2        0.0375             nan     0.0500    0.0015
##      3        0.0352             nan     0.0500    0.0014
##      4        0.0327             nan     0.0500    0.0025
##      5        0.0304             nan     0.0500    0.0017
##      6        0.0278             nan     0.0500    0.0017
##      7        0.0265             nan     0.0500    0.0012
##      8        0.0256             nan     0.0500    0.0001
##      9        0.0238             nan     0.0500    0.0005
##     10        0.0234             nan     0.0500    0.0000
##     20        0.0121             nan     0.0500    0.0008
##     40        0.0033             nan     0.0500    0.0001
##     60        0.0013             nan     0.0500    0.0001
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0026
##      2        0.0382             nan     0.0500    0.0028
##      3        0.0358             nan     0.0500    0.0014
##      4        0.0333             nan     0.0500    0.0015
##      5        0.0313             nan     0.0500    0.0009
##      6        0.0289             nan     0.0500    0.0023
##      7        0.0266             nan     0.0500    0.0013
##      8        0.0250             nan     0.0500    0.0009
##      9        0.0228             nan     0.0500    0.0016
##     10        0.0214             nan     0.0500    0.0008
##     20        0.0122             nan     0.0500    0.0009
##     40        0.0046             nan     0.0500    0.0001
##     60        0.0019             nan     0.0500    0.0000
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0023
##      2        0.0391             nan     0.0500    0.0018
##      3        0.0367             nan     0.0500    0.0008
##      4        0.0347             nan     0.0500    0.0007
##      5        0.0325             nan     0.0500    0.0009
##      6        0.0304             nan     0.0500    0.0015
##      7        0.0284             nan     0.0500    0.0015
##      8        0.0270             nan     0.0500    0.0007
##      9        0.0253             nan     0.0500    0.0011
##     10        0.0242             nan     0.0500    0.0007
##     20        0.0159             nan     0.0500    0.0009
##     40        0.0085             nan     0.0500   -0.0001
##     60        0.0052             nan     0.0500    0.0001
##     80        0.0033             nan     0.0500   -0.0001
##    100        0.0025             nan     0.0500   -0.0001
##    120        0.0018             nan     0.0500   -0.0001
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0019
##      2        0.0388             nan     0.0500    0.0011
##      3        0.0354             nan     0.0500    0.0034
##      4        0.0337             nan     0.0500    0.0008
##      5        0.0325             nan     0.0500   -0.0004
##      6        0.0298             nan     0.0500    0.0021
##      7        0.0275             nan     0.0500    0.0020
##      8        0.0256             nan     0.0500    0.0017
##      9        0.0240             nan     0.0500    0.0015
##     10        0.0220             nan     0.0500    0.0019
##     20        0.0112             nan     0.0500    0.0002
##     40        0.0031             nan     0.0500    0.0000
##     60        0.0013             nan     0.0500    0.0000
##     80        0.0005             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0500   -0.0001
##      2        0.0393             nan     0.0500    0.0017
##      3        0.0364             nan     0.0500    0.0022
##      4        0.0341             nan     0.0500    0.0019
##      5        0.0319             nan     0.0500    0.0015
##      6        0.0295             nan     0.0500    0.0020
##      7        0.0264             nan     0.0500    0.0019
##      8        0.0241             nan     0.0500    0.0016
##      9        0.0228             nan     0.0500    0.0016
##     10        0.0218             nan     0.0500    0.0009
##     20        0.0121             nan     0.0500    0.0004
##     40        0.0039             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.0500    0.0020
##      2        0.0368             nan     0.0500    0.0016
##      3        0.0343             nan     0.0500    0.0020
##      4        0.0317             nan     0.0500    0.0021
##      5        0.0304             nan     0.0500    0.0002
##      6        0.0291             nan     0.0500    0.0014
##      7        0.0273             nan     0.0500    0.0010
##      8        0.0257             nan     0.0500    0.0015
##      9        0.0249             nan     0.0500    0.0002
##     10        0.0245             nan     0.0500   -0.0001
##     20        0.0161             nan     0.0500    0.0003
##     40        0.0084             nan     0.0500   -0.0000
##     60        0.0046             nan     0.0500    0.0001
##     80        0.0029             nan     0.0500   -0.0000
##    100        0.0021             nan     0.0500   -0.0001
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.1000    0.0049
##      2        0.0317             nan     0.1000    0.0043
##      3        0.0289             nan     0.1000    0.0029
##      4        0.0252             nan     0.1000    0.0024
##      5        0.0237             nan     0.1000    0.0015
##      6        0.0215             nan     0.1000    0.0022
##      7        0.0199             nan     0.1000   -0.0006
##      8        0.0171             nan     0.1000    0.0025
##      9        0.0156             nan     0.1000    0.0001
##     10        0.0143             nan     0.1000    0.0013
##     20        0.0071             nan     0.1000    0.0004
##     40        0.0018             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0364             nan     0.1000    0.0044
##      2        0.0320             nan     0.1000    0.0046
##      3        0.0277             nan     0.1000    0.0025
##      4        0.0239             nan     0.1000    0.0024
##      5        0.0221             nan     0.1000    0.0014
##      6        0.0191             nan     0.1000    0.0011
##      7        0.0171             nan     0.1000    0.0003
##      8        0.0151             nan     0.1000    0.0017
##      9        0.0131             nan     0.1000    0.0014
##     10        0.0122             nan     0.1000    0.0006
##     20        0.0060             nan     0.1000    0.0003
##     40        0.0017             nan     0.1000   -0.0001
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000    0.0049
##      2        0.0332             nan     0.1000    0.0043
##      3        0.0287             nan     0.1000    0.0040
##      4        0.0260             nan     0.1000    0.0031
##      5        0.0230             nan     0.1000    0.0015
##      6        0.0209             nan     0.1000    0.0023
##      7        0.0188             nan     0.1000    0.0019
##      8        0.0172             nan     0.1000   -0.0006
##      9        0.0161             nan     0.1000    0.0002
##     10        0.0144             nan     0.1000    0.0017
##     20        0.0075             nan     0.1000    0.0006
##     40        0.0030             nan     0.1000    0.0000
##     60        0.0015             nan     0.1000   -0.0000
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0001
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.1000    0.0026
##      2        0.0352             nan     0.1000    0.0023
##      3        0.0308             nan     0.1000    0.0035
##      4        0.0268             nan     0.1000    0.0026
##      5        0.0227             nan     0.1000    0.0042
##      6        0.0207             nan     0.1000   -0.0014
##      7        0.0184             nan     0.1000    0.0013
##      8        0.0161             nan     0.1000    0.0010
##      9        0.0145             nan     0.1000    0.0014
##     10        0.0124             nan     0.1000    0.0014
##     20        0.0038             nan     0.1000    0.0005
##     40        0.0007             nan     0.1000    0.0001
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0032
##      2        0.0341             nan     0.1000   -0.0004
##      3        0.0300             nan     0.1000    0.0044
##      4        0.0260             nan     0.1000    0.0040
##      5        0.0230             nan     0.1000    0.0028
##      6        0.0206             nan     0.1000    0.0011
##      7        0.0184             nan     0.1000    0.0020
##      8        0.0154             nan     0.1000    0.0024
##      9        0.0137             nan     0.1000    0.0016
##     10        0.0121             nan     0.1000    0.0015
##     20        0.0054             nan     0.1000   -0.0004
##     40        0.0008             nan     0.1000    0.0001
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.1000    0.0027
##      2        0.0338             nan     0.1000    0.0054
##      3        0.0307             nan     0.1000    0.0011
##      4        0.0271             nan     0.1000    0.0037
##      5        0.0238             nan     0.1000    0.0028
##      6        0.0214             nan     0.1000    0.0014
##      7        0.0199             nan     0.1000    0.0009
##      8        0.0193             nan     0.1000   -0.0019
##      9        0.0175             nan     0.1000    0.0018
##     10        0.0165             nan     0.1000    0.0007
##     20        0.0082             nan     0.1000    0.0003
##     40        0.0034             nan     0.1000    0.0000
##     60        0.0020             nan     0.1000    0.0000
##     80        0.0010             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0042
##      2        0.0334             nan     0.1000    0.0054
##      3        0.0292             nan     0.1000    0.0018
##      4        0.0240             nan     0.1000    0.0041
##      5        0.0218             nan     0.1000    0.0016
##      6        0.0180             nan     0.1000    0.0031
##      7        0.0148             nan     0.1000    0.0026
##      8        0.0120             nan     0.1000    0.0028
##      9        0.0102             nan     0.1000    0.0006
##     10        0.0092             nan     0.1000    0.0001
##     20        0.0024             nan     0.1000    0.0002
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0045
##      2        0.0317             nan     0.1000    0.0049
##      3        0.0261             nan     0.1000    0.0027
##      4        0.0225             nan     0.1000    0.0041
##      5        0.0200             nan     0.1000    0.0005
##      6        0.0172             nan     0.1000    0.0011
##      7        0.0145             nan     0.1000    0.0017
##      8        0.0128             nan     0.1000    0.0007
##      9        0.0117             nan     0.1000    0.0004
##     10        0.0108             nan     0.1000    0.0007
##     20        0.0034             nan     0.1000    0.0004
##     40        0.0009             nan     0.1000    0.0000
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.1000    0.0053
##      2        0.0347             nan     0.1000    0.0033
##      3        0.0312             nan     0.1000    0.0039
##      4        0.0281             nan     0.1000    0.0018
##      5        0.0258             nan     0.1000    0.0026
##      6        0.0228             nan     0.1000    0.0028
##      7        0.0213             nan     0.1000    0.0010
##      8        0.0182             nan     0.1000    0.0015
##      9        0.0158             nan     0.1000    0.0011
##     10        0.0141             nan     0.1000    0.0013
##     20        0.0081             nan     0.1000    0.0003
##     40        0.0036             nan     0.1000   -0.0001
##     60        0.0016             nan     0.1000   -0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.0100    0.0005
##      2        0.0363             nan     0.0100    0.0000
##      3        0.0359             nan     0.0100    0.0004
##      4        0.0354             nan     0.0100    0.0002
##      5        0.0350             nan     0.0100    0.0005
##      6        0.0344             nan     0.0100    0.0005
##      7        0.0340             nan     0.0100    0.0003
##      8        0.0334             nan     0.0100    0.0005
##      9        0.0331             nan     0.0100    0.0003
##     10        0.0328             nan     0.0100    0.0004
##     20        0.0293             nan     0.0100    0.0004
##     40        0.0234             nan     0.0100    0.0003
##     60        0.0189             nan     0.0100    0.0002
##     80        0.0159             nan     0.0100    0.0000
##    100        0.0134             nan     0.0100   -0.0000
##    120        0.0110             nan     0.0100   -0.0000
##    140        0.0092             nan     0.0100    0.0000
##    160        0.0079             nan     0.0100    0.0001
##    180        0.0067             nan     0.0100    0.0000
##    200        0.0058             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0100    0.0002
##      2        0.0362             nan     0.0100    0.0004
##      3        0.0357             nan     0.0100    0.0005
##      4        0.0355             nan     0.0100    0.0001
##      5        0.0351             nan     0.0100    0.0003
##      6        0.0346             nan     0.0100    0.0003
##      7        0.0342             nan     0.0100    0.0004
##      8        0.0337             nan     0.0100    0.0004
##      9        0.0332             nan     0.0100    0.0004
##     10        0.0328             nan     0.0100    0.0004
##     20        0.0291             nan     0.0100    0.0002
##     40        0.0232             nan     0.0100    0.0003
##     60        0.0192             nan     0.0100    0.0002
##     80        0.0158             nan     0.0100    0.0002
##    100        0.0131             nan     0.0100    0.0001
##    120        0.0113             nan     0.0100    0.0001
##    140        0.0097             nan     0.0100    0.0000
##    160        0.0084             nan     0.0100    0.0000
##    180        0.0071             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100   -0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0100    0.0005
##      2        0.0362             nan     0.0100    0.0002
##      3        0.0358             nan     0.0100    0.0003
##      4        0.0353             nan     0.0100    0.0005
##      5        0.0350             nan     0.0100    0.0002
##      6        0.0346             nan     0.0100    0.0003
##      7        0.0341             nan     0.0100    0.0005
##      8        0.0336             nan     0.0100    0.0003
##      9        0.0333             nan     0.0100    0.0000
##     10        0.0329             nan     0.0100    0.0005
##     20        0.0295             nan     0.0100    0.0003
##     40        0.0237             nan     0.0100    0.0001
##     60        0.0193             nan     0.0100    0.0000
##     80        0.0158             nan     0.0100    0.0001
##    100        0.0134             nan     0.0100    0.0001
##    120        0.0115             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0000
##    160        0.0086             nan     0.0100   -0.0000
##    180        0.0076             nan     0.0100   -0.0000
##    200        0.0068             nan     0.0100   -0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0100    0.0005
##      2        0.0361             nan     0.0100    0.0006
##      3        0.0358             nan     0.0100    0.0001
##      4        0.0352             nan     0.0100    0.0006
##      5        0.0346             nan     0.0100    0.0004
##      6        0.0342             nan     0.0100    0.0003
##      7        0.0339             nan     0.0100    0.0002
##      8        0.0334             nan     0.0100    0.0003
##      9        0.0329             nan     0.0100    0.0005
##     10        0.0323             nan     0.0100    0.0004
##     20        0.0277             nan     0.0100    0.0003
##     40        0.0209             nan     0.0100    0.0003
##     60        0.0168             nan     0.0100   -0.0000
##     80        0.0129             nan     0.0100    0.0001
##    100        0.0102             nan     0.0100    0.0001
##    120        0.0081             nan     0.0100    0.0001
##    140        0.0065             nan     0.0100    0.0001
##    160        0.0054             nan     0.0100   -0.0000
##    180        0.0044             nan     0.0100    0.0000
##    200        0.0035             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.0100    0.0003
##      2        0.0363             nan     0.0100    0.0004
##      3        0.0357             nan     0.0100    0.0004
##      4        0.0354             nan     0.0100    0.0002
##      5        0.0348             nan     0.0100    0.0006
##      6        0.0344             nan     0.0100    0.0004
##      7        0.0342             nan     0.0100    0.0000
##      8        0.0337             nan     0.0100    0.0005
##      9        0.0334             nan     0.0100    0.0002
##     10        0.0329             nan     0.0100    0.0003
##     20        0.0286             nan     0.0100    0.0004
##     40        0.0226             nan     0.0100    0.0004
##     60        0.0179             nan     0.0100    0.0000
##     80        0.0141             nan     0.0100    0.0001
##    100        0.0113             nan     0.0100    0.0000
##    120        0.0091             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0000
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0051             nan     0.0100    0.0000
##    200        0.0042             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.0100    0.0003
##      2        0.0362             nan     0.0100    0.0005
##      3        0.0356             nan     0.0100    0.0005
##      4        0.0352             nan     0.0100    0.0002
##      5        0.0348             nan     0.0100    0.0003
##      6        0.0343             nan     0.0100    0.0004
##      7        0.0338             nan     0.0100    0.0004
##      8        0.0333             nan     0.0100    0.0003
##      9        0.0329             nan     0.0100    0.0004
##     10        0.0325             nan     0.0100    0.0003
##     20        0.0286             nan     0.0100    0.0002
##     40        0.0230             nan     0.0100   -0.0001
##     60        0.0187             nan     0.0100    0.0001
##     80        0.0156             nan     0.0100    0.0001
##    100        0.0131             nan     0.0100    0.0001
##    120        0.0114             nan     0.0100    0.0001
##    140        0.0100             nan     0.0100    0.0001
##    160        0.0090             nan     0.0100    0.0000
##    180        0.0080             nan     0.0100    0.0000
##    200        0.0072             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0100    0.0003
##      2        0.0360             nan     0.0100    0.0003
##      3        0.0353             nan     0.0100    0.0005
##      4        0.0348             nan     0.0100    0.0005
##      5        0.0342             nan     0.0100    0.0006
##      6        0.0337             nan     0.0100    0.0005
##      7        0.0331             nan     0.0100    0.0003
##      8        0.0325             nan     0.0100    0.0004
##      9        0.0321             nan     0.0100    0.0001
##     10        0.0316             nan     0.0100    0.0004
##     20        0.0273             nan     0.0100    0.0001
##     40        0.0205             nan     0.0100    0.0002
##     60        0.0157             nan     0.0100    0.0002
##     80        0.0120             nan     0.0100    0.0000
##    100        0.0093             nan     0.0100    0.0001
##    120        0.0072             nan     0.0100    0.0001
##    140        0.0054             nan     0.0100    0.0001
##    160        0.0043             nan     0.0100    0.0000
##    180        0.0033             nan     0.0100    0.0000
##    200        0.0027             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.0100    0.0004
##      2        0.0358             nan     0.0100    0.0005
##      3        0.0352             nan     0.0100    0.0003
##      4        0.0348             nan     0.0100    0.0002
##      5        0.0343             nan     0.0100    0.0003
##      6        0.0338             nan     0.0100    0.0005
##      7        0.0334             nan     0.0100    0.0003
##      8        0.0328             nan     0.0100    0.0005
##      9        0.0324             nan     0.0100    0.0005
##     10        0.0318             nan     0.0100    0.0004
##     20        0.0278             nan     0.0100    0.0003
##     40        0.0213             nan     0.0100    0.0003
##     60        0.0169             nan     0.0100    0.0002
##     80        0.0132             nan     0.0100    0.0001
##    100        0.0105             nan     0.0100    0.0001
##    120        0.0085             nan     0.0100    0.0001
##    140        0.0071             nan     0.0100   -0.0000
##    160        0.0057             nan     0.0100   -0.0000
##    180        0.0047             nan     0.0100    0.0001
##    200        0.0039             nan     0.0100   -0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0100    0.0006
##      2        0.0361             nan     0.0100    0.0005
##      3        0.0355             nan     0.0100    0.0005
##      4        0.0350             nan     0.0100    0.0004
##      5        0.0346             nan     0.0100    0.0004
##      6        0.0342             nan     0.0100    0.0003
##      7        0.0337             nan     0.0100    0.0005
##      8        0.0335             nan     0.0100    0.0000
##      9        0.0332             nan     0.0100    0.0003
##     10        0.0328             nan     0.0100    0.0000
##     20        0.0290             nan     0.0100    0.0003
##     40        0.0234             nan     0.0100    0.0003
##     60        0.0187             nan     0.0100    0.0002
##     80        0.0156             nan     0.0100    0.0001
##    100        0.0132             nan     0.0100    0.0000
##    120        0.0113             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0000
##    160        0.0087             nan     0.0100    0.0000
##    180        0.0078             nan     0.0100    0.0000
##    200        0.0070             nan     0.0100    0.0000
## 
## - Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0348             nan     0.0500    0.0023
##      2        0.0324             nan     0.0500    0.0023
##      3        0.0306             nan     0.0500    0.0016
##      4        0.0291             nan     0.0500    0.0015
##      5        0.0273             nan     0.0500    0.0007
##      6        0.0261             nan     0.0500    0.0009
##      7        0.0247             nan     0.0500    0.0004
##      8        0.0234             nan     0.0500    0.0014
##      9        0.0229             nan     0.0500   -0.0003
##     10        0.0220             nan     0.0500    0.0006
##     20        0.0137             nan     0.0500    0.0007
##     40        0.0066             nan     0.0500    0.0000
##     60        0.0034             nan     0.0500    0.0001
##     80        0.0017             nan     0.0500   -0.0000
##    100        0.0011             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0350             nan     0.0500    0.0024
##      2        0.0333             nan     0.0500    0.0018
##      3        0.0310             nan     0.0500    0.0023
##      4        0.0306             nan     0.0500   -0.0005
##      5        0.0287             nan     0.0500    0.0018
##      6        0.0268             nan     0.0500    0.0015
##      7        0.0253             nan     0.0500    0.0015
##      8        0.0238             nan     0.0500    0.0008
##      9        0.0226             nan     0.0500    0.0011
##     10        0.0219             nan     0.0500    0.0001
##     20        0.0138             nan     0.0500    0.0006
##     40        0.0060             nan     0.0500    0.0000
##     60        0.0037             nan     0.0500    0.0001
##     80        0.0021             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0008             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0353             nan     0.0500    0.0012
##      2        0.0329             nan     0.0500    0.0020
##      3        0.0306             nan     0.0500    0.0020
##      4        0.0285             nan     0.0500    0.0018
##      5        0.0266             nan     0.0500    0.0019
##      6        0.0259             nan     0.0500    0.0006
##      7        0.0245             nan     0.0500    0.0013
##      8        0.0239             nan     0.0500    0.0000
##      9        0.0224             nan     0.0500    0.0011
##     10        0.0212             nan     0.0500    0.0010
##     20        0.0138             nan     0.0500    0.0001
##     40        0.0072             nan     0.0500    0.0002
##     60        0.0043             nan     0.0500   -0.0000
##     80        0.0029             nan     0.0500    0.0000
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0015             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0361             nan     0.0500    0.0002
##      2        0.0335             nan     0.0500    0.0022
##      3        0.0309             nan     0.0500    0.0014
##      4        0.0285             nan     0.0500    0.0019
##      5        0.0270             nan     0.0500   -0.0004
##      6        0.0250             nan     0.0500    0.0015
##      7        0.0239             nan     0.0500    0.0010
##      8        0.0222             nan     0.0500    0.0007
##      9        0.0215             nan     0.0500   -0.0006
##     10        0.0198             nan     0.0500    0.0013
##     20        0.0101             nan     0.0500    0.0006
##     40        0.0038             nan     0.0500    0.0001
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0346             nan     0.0500    0.0017
##      2        0.0322             nan     0.0500    0.0018
##      3        0.0301             nan     0.0500    0.0010
##      4        0.0280             nan     0.0500    0.0019
##      5        0.0263             nan     0.0500    0.0014
##      6        0.0248             nan     0.0500    0.0008
##      7        0.0228             nan     0.0500    0.0017
##      8        0.0211             nan     0.0500    0.0008
##      9        0.0196             nan     0.0500    0.0006
##     10        0.0183             nan     0.0500    0.0013
##     20        0.0102             nan     0.0500    0.0005
##     40        0.0040             nan     0.0500    0.0000
##     60        0.0017             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0346             nan     0.0500    0.0012
##      2        0.0325             nan     0.0500    0.0021
##      3        0.0312             nan     0.0500   -0.0001
##      4        0.0296             nan     0.0500    0.0018
##      5        0.0279             nan     0.0500    0.0019
##      6        0.0263             nan     0.0500    0.0002
##      7        0.0252             nan     0.0500    0.0003
##      8        0.0241             nan     0.0500    0.0012
##      9        0.0225             nan     0.0500    0.0010
##     10        0.0214             nan     0.0500    0.0006
##     20        0.0135             nan     0.0500    0.0001
##     40        0.0068             nan     0.0500    0.0000
##     60        0.0044             nan     0.0500   -0.0001
##     80        0.0027             nan     0.0500    0.0000
##    100        0.0019             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0341             nan     0.0500    0.0035
##      2        0.0314             nan     0.0500    0.0012
##      3        0.0299             nan     0.0500    0.0004
##      4        0.0281             nan     0.0500    0.0012
##      5        0.0260             nan     0.0500    0.0017
##      6        0.0248             nan     0.0500    0.0010
##      7        0.0231             nan     0.0500    0.0014
##      8        0.0222             nan     0.0500    0.0005
##      9        0.0210             nan     0.0500    0.0005
##     10        0.0200             nan     0.0500    0.0002
##     20        0.0102             nan     0.0500    0.0004
##     40        0.0041             nan     0.0500    0.0000
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0360             nan     0.0500    0.0001
##      2        0.0334             nan     0.0500    0.0022
##      3        0.0312             nan     0.0500    0.0014
##      4        0.0294             nan     0.0500    0.0012
##      5        0.0278             nan     0.0500    0.0015
##      6        0.0262             nan     0.0500    0.0013
##      7        0.0248             nan     0.0500    0.0006
##      8        0.0230             nan     0.0500    0.0022
##      9        0.0216             nan     0.0500    0.0014
##     10        0.0199             nan     0.0500    0.0008
##     20        0.0117             nan     0.0500    0.0006
##     40        0.0044             nan     0.0500    0.0002
##     60        0.0022             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0352             nan     0.0500    0.0018
##      2        0.0338             nan     0.0500   -0.0005
##      3        0.0317             nan     0.0500    0.0020
##      4        0.0297             nan     0.0500    0.0021
##      5        0.0279             nan     0.0500    0.0010
##      6        0.0264             nan     0.0500    0.0017
##      7        0.0251             nan     0.0500    0.0006
##      8        0.0242             nan     0.0500    0.0003
##      9        0.0229             nan     0.0500    0.0012
##     10        0.0221             nan     0.0500    0.0008
##     20        0.0150             nan     0.0500    0.0003
##     40        0.0078             nan     0.0500    0.0001
##     60        0.0046             nan     0.0500   -0.0000
##     80        0.0032             nan     0.0500    0.0000
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500    0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0317             nan     0.1000    0.0052
##      2        0.0290             nan     0.1000   -0.0002
##      3        0.0259             nan     0.1000    0.0022
##      4        0.0234             nan     0.1000    0.0024
##      5        0.0225             nan     0.1000   -0.0007
##      6        0.0204             nan     0.1000    0.0021
##      7        0.0187             nan     0.1000    0.0020
##      8        0.0176             nan     0.1000    0.0000
##      9        0.0166             nan     0.1000   -0.0003
##     10        0.0147             nan     0.1000    0.0019
##     20        0.0066             nan     0.1000   -0.0000
##     40        0.0014             nan     0.1000    0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0320             nan     0.1000    0.0043
##      2        0.0281             nan     0.1000    0.0041
##      3        0.0239             nan     0.1000    0.0021
##      4        0.0221             nan     0.1000    0.0023
##      5        0.0205             nan     0.1000    0.0014
##      6        0.0188             nan     0.1000    0.0012
##      7        0.0160             nan     0.1000    0.0017
##      8        0.0148             nan     0.1000    0.0007
##      9        0.0139             nan     0.1000   -0.0002
##     10        0.0132             nan     0.1000    0.0000
##     20        0.0074             nan     0.1000    0.0005
##     40        0.0022             nan     0.1000   -0.0000
##     60        0.0008             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0325             nan     0.1000    0.0047
##      2        0.0291             nan     0.1000    0.0030
##      3        0.0249             nan     0.1000    0.0033
##      4        0.0218             nan     0.1000    0.0017
##      5        0.0198             nan     0.1000    0.0024
##      6        0.0184             nan     0.1000   -0.0013
##      7        0.0172             nan     0.1000    0.0008
##      8        0.0146             nan     0.1000    0.0015
##      9        0.0139             nan     0.1000    0.0005
##     10        0.0132             nan     0.1000    0.0003
##     20        0.0073             nan     0.1000    0.0005
##     40        0.0032             nan     0.1000   -0.0000
##     60        0.0016             nan     0.1000    0.0000
##     80        0.0008             nan     0.1000   -0.0001
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0327             nan     0.1000    0.0041
##      2        0.0274             nan     0.1000    0.0059
##      3        0.0236             nan     0.1000    0.0030
##      4        0.0196             nan     0.1000    0.0032
##      5        0.0168             nan     0.1000    0.0013
##      6        0.0152             nan     0.1000    0.0009
##      7        0.0132             nan     0.1000    0.0015
##      8        0.0114             nan     0.1000    0.0013
##      9        0.0099             nan     0.1000    0.0009
##     10        0.0089             nan     0.1000    0.0004
##     20        0.0034             nan     0.1000    0.0007
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0332             nan     0.1000    0.0024
##      2        0.0286             nan     0.1000    0.0024
##      3        0.0254             nan     0.1000    0.0028
##      4        0.0234             nan     0.1000    0.0012
##      5        0.0217             nan     0.1000    0.0016
##      6        0.0196             nan     0.1000   -0.0006
##      7        0.0175             nan     0.1000   -0.0000
##      8        0.0154             nan     0.1000    0.0015
##      9        0.0139             nan     0.1000    0.0010
##     10        0.0127             nan     0.1000    0.0008
##     20        0.0049             nan     0.1000    0.0001
##     40        0.0011             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0336             nan     0.1000    0.0027
##      2        0.0313             nan     0.1000    0.0001
##      3        0.0272             nan     0.1000    0.0025
##      4        0.0249             nan     0.1000    0.0022
##      5        0.0228             nan     0.1000    0.0014
##      6        0.0203             nan     0.1000    0.0023
##      7        0.0189             nan     0.1000    0.0012
##      8        0.0170             nan     0.1000    0.0014
##      9        0.0156             nan     0.1000    0.0008
##     10        0.0147             nan     0.1000    0.0000
##     20        0.0079             nan     0.1000   -0.0001
##     40        0.0029             nan     0.1000   -0.0003
##     60        0.0014             nan     0.1000   -0.0001
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0329             nan     0.1000    0.0001
##      2        0.0287             nan     0.1000    0.0011
##      3        0.0260             nan     0.1000    0.0024
##      4        0.0226             nan     0.1000    0.0038
##      5        0.0194             nan     0.1000    0.0022
##      6        0.0170             nan     0.1000    0.0023
##      7        0.0138             nan     0.1000    0.0020
##      8        0.0124             nan     0.1000    0.0010
##      9        0.0121             nan     0.1000   -0.0003
##     10        0.0106             nan     0.1000    0.0012
##     20        0.0031             nan     0.1000    0.0003
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0317             nan     0.1000    0.0048
##      2        0.0276             nan     0.1000    0.0035
##      3        0.0237             nan     0.1000    0.0040
##      4        0.0190             nan     0.1000    0.0021
##      5        0.0167             nan     0.1000    0.0024
##      6        0.0140             nan     0.1000    0.0009
##      7        0.0121             nan     0.1000    0.0015
##      8        0.0107             nan     0.1000    0.0010
##      9        0.0092             nan     0.1000   -0.0001
##     10        0.0079             nan     0.1000    0.0007
##     20        0.0033             nan     0.1000   -0.0001
##     40        0.0010             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0318             nan     0.1000    0.0049
##      2        0.0279             nan     0.1000    0.0015
##      3        0.0247             nan     0.1000    0.0036
##      4        0.0224             nan     0.1000    0.0024
##      5        0.0200             nan     0.1000    0.0018
##      6        0.0186             nan     0.1000    0.0002
##      7        0.0176             nan     0.1000    0.0008
##      8        0.0160             nan     0.1000    0.0008
##      9        0.0146             nan     0.1000    0.0007
##     10        0.0134             nan     0.1000    0.0010
##     20        0.0068             nan     0.1000    0.0000
##     40        0.0029             nan     0.1000    0.0000
##     60        0.0013             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0002
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0423             nan     0.0100    0.0004
##      4        0.0418             nan     0.0100    0.0005
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0404             nan     0.0100    0.0003
##      8        0.0399             nan     0.0100    0.0004
##      9        0.0394             nan     0.0100    0.0004
##     10        0.0390             nan     0.0100    0.0000
##     20        0.0347             nan     0.0100    0.0003
##     40        0.0272             nan     0.0100    0.0002
##     60        0.0218             nan     0.0100    0.0001
##     80        0.0173             nan     0.0100    0.0002
##    100        0.0143             nan     0.0100    0.0001
##    120        0.0120             nan     0.0100    0.0000
##    140        0.0102             nan     0.0100    0.0000
##    160        0.0086             nan     0.0100    0.0001
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0061             nan     0.0100    0.0001
## 
## - Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0000
##      2        0.0428             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0006
##      4        0.0416             nan     0.0100    0.0005
##      5        0.0411             nan     0.0100    0.0005
##      6        0.0405             nan     0.0100    0.0005
##      7        0.0401             nan     0.0100    0.0003
##      8        0.0395             nan     0.0100    0.0006
##      9        0.0389             nan     0.0100    0.0005
##     10        0.0386             nan     0.0100    0.0000
##     20        0.0347             nan     0.0100    0.0001
##     40        0.0284             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0003
##     80        0.0187             nan     0.0100    0.0002
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0129             nan     0.0100   -0.0000
##    140        0.0109             nan     0.0100    0.0000
##    160        0.0092             nan     0.0100    0.0000
##    180        0.0079             nan     0.0100    0.0000
##    200        0.0067             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0005
##      2        0.0426             nan     0.0100    0.0005
##      3        0.0421             nan     0.0100    0.0006
##      4        0.0416             nan     0.0100    0.0003
##      5        0.0412             nan     0.0100    0.0004
##      6        0.0407             nan     0.0100    0.0001
##      7        0.0401             nan     0.0100    0.0005
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0390             nan     0.0100    0.0005
##     10        0.0386             nan     0.0100    0.0002
##     20        0.0347             nan     0.0100    0.0005
##     40        0.0278             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0003
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0160             nan     0.0100    0.0002
##    120        0.0137             nan     0.0100    0.0000
##    140        0.0114             nan     0.0100   -0.0000
##    160        0.0101             nan     0.0100    0.0001
##    180        0.0088             nan     0.0100   -0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100   -0.0003
##      2        0.0432             nan     0.0100    0.0005
##      3        0.0426             nan     0.0100    0.0004
##      4        0.0419             nan     0.0100    0.0004
##      5        0.0411             nan     0.0100    0.0007
##      6        0.0406             nan     0.0100    0.0005
##      7        0.0401             nan     0.0100    0.0006
##      8        0.0396             nan     0.0100    0.0003
##      9        0.0390             nan     0.0100    0.0006
##     10        0.0384             nan     0.0100    0.0005
##     20        0.0331             nan     0.0100    0.0005
##     40        0.0256             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0001
##     80        0.0150             nan     0.0100    0.0002
##    100        0.0119             nan     0.0100    0.0001
##    120        0.0091             nan     0.0100    0.0001
##    140        0.0072             nan     0.0100   -0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100    0.0000
##    200        0.0037             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0006
##      2        0.0423             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100    0.0002
##      4        0.0412             nan     0.0100    0.0003
##      5        0.0407             nan     0.0100    0.0004
##      6        0.0401             nan     0.0100    0.0004
##      7        0.0393             nan     0.0100    0.0006
##      8        0.0390             nan     0.0100   -0.0000
##      9        0.0383             nan     0.0100    0.0005
##     10        0.0376             nan     0.0100    0.0005
##     20        0.0325             nan     0.0100    0.0002
##     40        0.0251             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0002
##     80        0.0154             nan     0.0100    0.0001
##    100        0.0128             nan     0.0100    0.0000
##    120        0.0104             nan     0.0100    0.0000
##    140        0.0084             nan     0.0100    0.0001
##    160        0.0066             nan     0.0100    0.0001
##    180        0.0056             nan     0.0100    0.0000
##    200        0.0047             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0005
##      2        0.0427             nan     0.0100    0.0004
##      3        0.0420             nan     0.0100    0.0006
##      4        0.0414             nan     0.0100    0.0006
##      5        0.0408             nan     0.0100    0.0005
##      6        0.0402             nan     0.0100    0.0006
##      7        0.0399             nan     0.0100    0.0001
##      8        0.0397             nan     0.0100    0.0000
##      9        0.0393             nan     0.0100    0.0003
##     10        0.0388             nan     0.0100    0.0005
##     20        0.0352             nan     0.0100    0.0001
##     40        0.0283             nan     0.0100    0.0002
##     60        0.0231             nan     0.0100    0.0001
##     80        0.0195             nan     0.0100    0.0001
##    100        0.0161             nan     0.0100    0.0001
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0119             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0090             nan     0.0100   -0.0000
##    200        0.0082             nan     0.0100   -0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0001
##      2        0.0425             nan     0.0100    0.0008
##      3        0.0420             nan     0.0100    0.0003
##      4        0.0414             nan     0.0100    0.0003
##      5        0.0407             nan     0.0100    0.0007
##      6        0.0400             nan     0.0100    0.0008
##      7        0.0394             nan     0.0100    0.0003
##      8        0.0385             nan     0.0100    0.0007
##      9        0.0379             nan     0.0100    0.0005
##     10        0.0373             nan     0.0100    0.0003
##     20        0.0320             nan     0.0100    0.0004
##     40        0.0243             nan     0.0100    0.0003
##     60        0.0188             nan     0.0100    0.0003
##     80        0.0144             nan     0.0100   -0.0000
##    100        0.0109             nan     0.0100    0.0000
##    120        0.0083             nan     0.0100   -0.0000
##    140        0.0066             nan     0.0100    0.0000
##    160        0.0053             nan     0.0100    0.0000
##    180        0.0042             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0428             nan     0.0100    0.0004
##      3        0.0421             nan     0.0100    0.0007
##      4        0.0417             nan     0.0100    0.0003
##      5        0.0409             nan     0.0100    0.0004
##      6        0.0401             nan     0.0100    0.0003
##      7        0.0394             nan     0.0100    0.0006
##      8        0.0388             nan     0.0100    0.0004
##      9        0.0384             nan     0.0100    0.0004
##     10        0.0379             nan     0.0100    0.0004
##     20        0.0328             nan     0.0100    0.0003
##     40        0.0245             nan     0.0100    0.0002
##     60        0.0186             nan     0.0100    0.0002
##     80        0.0145             nan     0.0100    0.0002
##    100        0.0115             nan     0.0100    0.0001
##    120        0.0090             nan     0.0100    0.0000
##    140        0.0072             nan     0.0100    0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0004
##      2        0.0425             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0003
##      4        0.0418             nan     0.0100    0.0003
##      5        0.0413             nan     0.0100    0.0004
##      6        0.0409             nan     0.0100    0.0003
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0400             nan     0.0100   -0.0002
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0005
##     20        0.0347             nan     0.0100    0.0004
##     40        0.0284             nan     0.0100   -0.0000
##     60        0.0235             nan     0.0100   -0.0001
##     80        0.0193             nan     0.0100    0.0002
##    100        0.0165             nan     0.0100   -0.0000
##    120        0.0141             nan     0.0100    0.0001
##    140        0.0124             nan     0.0100    0.0000
##    160        0.0110             nan     0.0100   -0.0001
##    180        0.0097             nan     0.0100    0.0000
##    200        0.0087             nan     0.0100    0.0000
## 
## - Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0023
##      2        0.0389             nan     0.0500    0.0017
##      3        0.0366             nan     0.0500    0.0010
##      4        0.0352             nan     0.0500    0.0014
##      5        0.0342             nan     0.0500   -0.0003
##      6        0.0319             nan     0.0500    0.0015
##      7        0.0307             nan     0.0500    0.0011
##      8        0.0292             nan     0.0500    0.0007
##      9        0.0274             nan     0.0500    0.0011
##     10        0.0266             nan     0.0500    0.0006
##     20        0.0168             nan     0.0500    0.0009
##     40        0.0080             nan     0.0500   -0.0000
##     60        0.0044             nan     0.0500    0.0001
##     80        0.0025             nan     0.0500   -0.0001
##    100        0.0014             nan     0.0500   -0.0000
##    120        0.0009             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0004             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0030
##      2        0.0382             nan     0.0500    0.0015
##      3        0.0360             nan     0.0500    0.0016
##      4        0.0343             nan     0.0500    0.0020
##      5        0.0320             nan     0.0500    0.0023
##      6        0.0305             nan     0.0500    0.0015
##      7        0.0281             nan     0.0500    0.0012
##      8        0.0268             nan     0.0500    0.0011
##      9        0.0252             nan     0.0500    0.0013
##     10        0.0237             nan     0.0500    0.0005
##     20        0.0146             nan     0.0500    0.0007
##     40        0.0059             nan     0.0500   -0.0001
##     60        0.0033             nan     0.0500   -0.0000
##     80        0.0019             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500    0.0000
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0024
##      2        0.0383             nan     0.0500    0.0027
##      3        0.0363             nan     0.0500    0.0016
##      4        0.0342             nan     0.0500    0.0023
##      5        0.0321             nan     0.0500    0.0020
##      6        0.0303             nan     0.0500    0.0018
##      7        0.0286             nan     0.0500    0.0013
##      8        0.0275             nan     0.0500    0.0002
##      9        0.0264             nan     0.0500    0.0004
##     10        0.0248             nan     0.0500    0.0015
##     20        0.0153             nan     0.0500    0.0004
##     40        0.0075             nan     0.0500    0.0002
##     60        0.0043             nan     0.0500    0.0000
##     80        0.0028             nan     0.0500   -0.0000
##    100        0.0018             nan     0.0500   -0.0000
##    120        0.0011             nan     0.0500    0.0000
##    140        0.0008             nan     0.0500    0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500    0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0010
##      2        0.0395             nan     0.0500    0.0021
##      3        0.0366             nan     0.0500    0.0029
##      4        0.0342             nan     0.0500    0.0022
##      5        0.0319             nan     0.0500    0.0025
##      6        0.0296             nan     0.0500    0.0004
##      7        0.0272             nan     0.0500    0.0018
##      8        0.0253             nan     0.0500    0.0016
##      9        0.0235             nan     0.0500    0.0016
##     10        0.0218             nan     0.0500    0.0017
##     20        0.0118             nan     0.0500    0.0001
##     40        0.0042             nan     0.0500    0.0001
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0009
##      2        0.0386             nan     0.0500    0.0021
##      3        0.0360             nan     0.0500    0.0013
##      4        0.0331             nan     0.0500    0.0013
##      5        0.0311             nan     0.0500    0.0021
##      6        0.0284             nan     0.0500    0.0015
##      7        0.0274             nan     0.0500    0.0008
##      8        0.0257             nan     0.0500    0.0018
##      9        0.0238             nan     0.0500    0.0004
##     10        0.0231             nan     0.0500    0.0000
##     20        0.0118             nan     0.0500    0.0005
##     40        0.0044             nan     0.0500    0.0001
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0010             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0027
##      2        0.0388             nan     0.0500    0.0027
##      3        0.0372             nan     0.0500    0.0017
##      4        0.0345             nan     0.0500    0.0024
##      5        0.0328             nan     0.0500    0.0003
##      6        0.0307             nan     0.0500    0.0017
##      7        0.0290             nan     0.0500    0.0008
##      8        0.0273             nan     0.0500    0.0016
##      9        0.0254             nan     0.0500    0.0014
##     10        0.0237             nan     0.0500    0.0014
##     20        0.0153             nan     0.0500    0.0007
##     40        0.0073             nan     0.0500    0.0001
##     60        0.0050             nan     0.0500   -0.0000
##     80        0.0033             nan     0.0500    0.0001
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0020
##      2        0.0384             nan     0.0500    0.0022
##      3        0.0356             nan     0.0500    0.0022
##      4        0.0332             nan     0.0500    0.0018
##      5        0.0303             nan     0.0500    0.0019
##      6        0.0279             nan     0.0500    0.0019
##      7        0.0262             nan     0.0500    0.0012
##      8        0.0251             nan     0.0500   -0.0001
##      9        0.0234             nan     0.0500    0.0007
##     10        0.0208             nan     0.0500    0.0028
##     20        0.0123             nan     0.0500    0.0001
##     40        0.0045             nan     0.0500   -0.0000
##     60        0.0018             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0500    0.0002
##      2        0.0401             nan     0.0500    0.0010
##      3        0.0371             nan     0.0500    0.0023
##      4        0.0341             nan     0.0500    0.0012
##      5        0.0314             nan     0.0500    0.0026
##      6        0.0294             nan     0.0500    0.0015
##      7        0.0273             nan     0.0500    0.0018
##      8        0.0257             nan     0.0500    0.0019
##      9        0.0234             nan     0.0500    0.0021
##     10        0.0215             nan     0.0500    0.0017
##     20        0.0117             nan     0.0500    0.0005
##     40        0.0047             nan     0.0500    0.0001
##     60        0.0022             nan     0.0500   -0.0000
##     80        0.0013             nan     0.0500   -0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0019
##      2        0.0394             nan     0.0500    0.0025
##      3        0.0371             nan     0.0500    0.0018
##      4        0.0346             nan     0.0500    0.0018
##      5        0.0322             nan     0.0500    0.0021
##      6        0.0314             nan     0.0500   -0.0005
##      7        0.0296             nan     0.0500    0.0007
##      8        0.0280             nan     0.0500    0.0003
##      9        0.0268             nan     0.0500    0.0007
##     10        0.0245             nan     0.0500    0.0011
##     20        0.0162             nan     0.0500    0.0003
##     40        0.0087             nan     0.0500   -0.0001
##     60        0.0053             nan     0.0500   -0.0001
##     80        0.0033             nan     0.0500    0.0000
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.1000    0.0033
##      2        0.0364             nan     0.1000    0.0009
##      3        0.0329             nan     0.1000    0.0039
##      4        0.0301             nan     0.1000    0.0025
##      5        0.0267             nan     0.1000    0.0032
##      6        0.0242             nan     0.1000    0.0024
##      7        0.0213             nan     0.1000    0.0028
##      8        0.0207             nan     0.1000   -0.0016
##      9        0.0183             nan     0.1000    0.0023
##     10        0.0166             nan     0.1000    0.0013
##     20        0.0076             nan     0.1000    0.0008
##     40        0.0022             nan     0.1000   -0.0000
##     60        0.0007             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.1000    0.0025
##      2        0.0337             nan     0.1000    0.0046
##      3        0.0301             nan     0.1000    0.0020
##      4        0.0268             nan     0.1000    0.0034
##      5        0.0247             nan     0.1000    0.0020
##      6        0.0227             nan     0.1000    0.0022
##      7        0.0214             nan     0.1000   -0.0008
##      8        0.0186             nan     0.1000    0.0017
##      9        0.0173             nan     0.1000    0.0008
##     10        0.0164             nan     0.1000    0.0007
##     20        0.0070             nan     0.1000   -0.0001
##     40        0.0024             nan     0.1000   -0.0000
##     60        0.0008             nan     0.1000    0.0001
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.1000   -0.0008
##      2        0.0369             nan     0.1000    0.0033
##      3        0.0317             nan     0.1000    0.0020
##      4        0.0293             nan     0.1000    0.0018
##      5        0.0272             nan     0.1000   -0.0006
##      6        0.0235             nan     0.1000    0.0018
##      7        0.0207             nan     0.1000    0.0023
##      8        0.0188             nan     0.1000    0.0001
##      9        0.0168             nan     0.1000    0.0012
##     10        0.0152             nan     0.1000    0.0006
##     20        0.0072             nan     0.1000   -0.0002
##     40        0.0032             nan     0.1000    0.0001
##     60        0.0019             nan     0.1000   -0.0000
##     80        0.0012             nan     0.1000   -0.0001
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0031
##      2        0.0321             nan     0.1000    0.0031
##      3        0.0276             nan     0.1000    0.0026
##      4        0.0247             nan     0.1000    0.0008
##      5        0.0216             nan     0.1000    0.0018
##      6        0.0188             nan     0.1000    0.0023
##      7        0.0173             nan     0.1000    0.0004
##      8        0.0144             nan     0.1000    0.0021
##      9        0.0138             nan     0.1000   -0.0002
##     10        0.0128             nan     0.1000    0.0001
##     20        0.0038             nan     0.1000    0.0007
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0066
##      2        0.0315             nan     0.1000    0.0052
##      3        0.0284             nan     0.1000    0.0027
##      4        0.0260             nan     0.1000    0.0007
##      5        0.0222             nan     0.1000    0.0016
##      6        0.0195             nan     0.1000    0.0026
##      7        0.0175             nan     0.1000    0.0014
##      8        0.0152             nan     0.1000    0.0015
##      9        0.0140             nan     0.1000    0.0009
##     10        0.0129             nan     0.1000    0.0009
##     20        0.0045             nan     0.1000    0.0003
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0386             nan     0.1000    0.0057
##      2        0.0350             nan     0.1000    0.0038
##      3        0.0325             nan     0.1000    0.0008
##      4        0.0296             nan     0.1000    0.0025
##      5        0.0262             nan     0.1000    0.0024
##      6        0.0233             nan     0.1000    0.0020
##      7        0.0215             nan     0.1000    0.0017
##      8        0.0197             nan     0.1000    0.0014
##      9        0.0189             nan     0.1000   -0.0012
##     10        0.0174             nan     0.1000    0.0011
##     20        0.0098             nan     0.1000   -0.0002
##     40        0.0036             nan     0.1000    0.0001
##     60        0.0018             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000    0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0386             nan     0.1000    0.0035
##      2        0.0316             nan     0.1000    0.0038
##      3        0.0269             nan     0.1000    0.0035
##      4        0.0250             nan     0.1000    0.0011
##      5        0.0221             nan     0.1000    0.0018
##      6        0.0188             nan     0.1000    0.0015
##      7        0.0158             nan     0.1000    0.0010
##      8        0.0138             nan     0.1000    0.0021
##      9        0.0119             nan     0.1000    0.0010
##     10        0.0110             nan     0.1000    0.0002
##     20        0.0041             nan     0.1000    0.0002
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000    0.0037
##      2        0.0325             nan     0.1000    0.0060
##      3        0.0276             nan     0.1000    0.0022
##      4        0.0246             nan     0.1000    0.0026
##      5        0.0209             nan     0.1000    0.0028
##      6        0.0179             nan     0.1000    0.0026
##      7        0.0161             nan     0.1000    0.0013
##      8        0.0141             nan     0.1000    0.0018
##      9        0.0124             nan     0.1000    0.0015
##     10        0.0114             nan     0.1000    0.0003
##     20        0.0042             nan     0.1000   -0.0001
##     40        0.0011             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.1000    0.0059
##      2        0.0348             nan     0.1000    0.0009
##      3        0.0334             nan     0.1000   -0.0007
##      4        0.0308             nan     0.1000   -0.0002
##      5        0.0270             nan     0.1000    0.0027
##      6        0.0259             nan     0.1000   -0.0009
##      7        0.0256             nan     0.1000   -0.0009
##      8        0.0234             nan     0.1000    0.0007
##      9        0.0204             nan     0.1000    0.0017
##     10        0.0190             nan     0.1000    0.0005
##     20        0.0099             nan     0.1000    0.0008
##     40        0.0036             nan     0.1000   -0.0001
##     60        0.0019             nan     0.1000    0.0000
##     80        0.0012             nan     0.1000   -0.0001
##    100        0.0007             nan     0.1000    0.0000
##    120        0.0005             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0002             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0007
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0421             nan     0.0100    0.0004
##      4        0.0417             nan     0.0100    0.0002
##      5        0.0412             nan     0.0100    0.0005
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0404             nan     0.0100    0.0004
##      8        0.0398             nan     0.0100    0.0005
##      9        0.0393             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0004
##     20        0.0343             nan     0.0100    0.0003
##     40        0.0269             nan     0.0100    0.0003
##     60        0.0214             nan     0.0100    0.0002
##     80        0.0174             nan     0.0100    0.0002
##    100        0.0139             nan     0.0100    0.0001
##    120        0.0115             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0001
##    160        0.0081             nan     0.0100    0.0001
##    180        0.0069             nan     0.0100    0.0001
##    200        0.0057             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0100    0.0006
##      2        0.0426             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0001
##      4        0.0418             nan     0.0100    0.0004
##      5        0.0415             nan     0.0100    0.0001
##      6        0.0409             nan     0.0100    0.0006
##      7        0.0405             nan     0.0100    0.0003
##      8        0.0400             nan     0.0100    0.0005
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0006
##     20        0.0341             nan     0.0100    0.0004
##     40        0.0275             nan     0.0100   -0.0000
##     60        0.0224             nan     0.0100    0.0001
##     80        0.0182             nan     0.0100    0.0002
##    100        0.0150             nan     0.0100    0.0001
##    120        0.0126             nan     0.0100    0.0001
##    140        0.0103             nan     0.0100    0.0000
##    160        0.0088             nan     0.0100    0.0000
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0006
##      2        0.0429             nan     0.0100    0.0006
##      3        0.0424             nan     0.0100    0.0001
##      4        0.0420             nan     0.0100    0.0001
##      5        0.0414             nan     0.0100    0.0005
##      6        0.0412             nan     0.0100    0.0001
##      7        0.0406             nan     0.0100    0.0004
##      8        0.0401             nan     0.0100    0.0005
##      9        0.0396             nan     0.0100    0.0004
##     10        0.0391             nan     0.0100    0.0001
##     20        0.0351             nan     0.0100    0.0005
##     40        0.0280             nan     0.0100    0.0001
##     60        0.0226             nan     0.0100    0.0000
##     80        0.0186             nan     0.0100    0.0001
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0133             nan     0.0100    0.0001
##    140        0.0116             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100   -0.0001
##    180        0.0090             nan     0.0100    0.0000
##    200        0.0082             nan     0.0100   -0.0001
## 
## - Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0004
##      2        0.0428             nan     0.0100    0.0003
##      3        0.0421             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100    0.0004
##      5        0.0409             nan     0.0100    0.0005
##      6        0.0404             nan     0.0100    0.0004
##      7        0.0397             nan     0.0100    0.0005
##      8        0.0390             nan     0.0100    0.0006
##      9        0.0384             nan     0.0100    0.0004
##     10        0.0379             nan     0.0100    0.0006
##     20        0.0330             nan     0.0100    0.0003
##     40        0.0250             nan     0.0100    0.0005
##     60        0.0188             nan     0.0100    0.0002
##     80        0.0143             nan     0.0100    0.0001
##    100        0.0113             nan     0.0100    0.0002
##    120        0.0092             nan     0.0100    0.0000
##    140        0.0074             nan     0.0100   -0.0000
##    160        0.0059             nan     0.0100    0.0001
##    180        0.0048             nan     0.0100    0.0001
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0100    0.0005
##      2        0.0425             nan     0.0100    0.0004
##      3        0.0418             nan     0.0100    0.0004
##      4        0.0414             nan     0.0100    0.0001
##      5        0.0408             nan     0.0100    0.0006
##      6        0.0402             nan     0.0100    0.0006
##      7        0.0396             nan     0.0100    0.0004
##      8        0.0390             nan     0.0100    0.0004
##      9        0.0386             nan     0.0100    0.0004
##     10        0.0380             nan     0.0100    0.0005
##     20        0.0329             nan     0.0100    0.0002
##     40        0.0249             nan     0.0100    0.0003
##     60        0.0195             nan     0.0100    0.0002
##     80        0.0150             nan     0.0100    0.0000
##    100        0.0118             nan     0.0100    0.0002
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0073             nan     0.0100    0.0001
##    160        0.0058             nan     0.0100    0.0001
##    180        0.0048             nan     0.0100   -0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0006
##      2        0.0427             nan     0.0100    0.0004
##      3        0.0424             nan     0.0100    0.0002
##      4        0.0418             nan     0.0100    0.0005
##      5        0.0413             nan     0.0100    0.0004
##      6        0.0408             nan     0.0100    0.0006
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0397             nan     0.0100    0.0005
##      9        0.0394             nan     0.0100    0.0001
##     10        0.0391             nan     0.0100    0.0003
##     20        0.0345             nan     0.0100    0.0003
##     40        0.0279             nan     0.0100    0.0003
##     60        0.0233             nan     0.0100    0.0001
##     80        0.0192             nan     0.0100    0.0002
##    100        0.0160             nan     0.0100   -0.0000
##    120        0.0137             nan     0.0100    0.0001
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0105             nan     0.0100   -0.0000
##    180        0.0093             nan     0.0100    0.0000
##    200        0.0083             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100   -0.0000
##      2        0.0432             nan     0.0100    0.0005
##      3        0.0429             nan     0.0100    0.0003
##      4        0.0424             nan     0.0100    0.0001
##      5        0.0418             nan     0.0100    0.0004
##      6        0.0411             nan     0.0100    0.0003
##      7        0.0404             nan     0.0100    0.0008
##      8        0.0398             nan     0.0100    0.0006
##      9        0.0390             nan     0.0100    0.0007
##     10        0.0383             nan     0.0100    0.0006
##     20        0.0333             nan     0.0100    0.0005
##     40        0.0253             nan     0.0100    0.0001
##     60        0.0184             nan     0.0100    0.0004
##     80        0.0138             nan     0.0100    0.0001
##    100        0.0105             nan     0.0100   -0.0001
##    120        0.0081             nan     0.0100    0.0001
##    140        0.0064             nan     0.0100    0.0001
##    160        0.0050             nan     0.0100    0.0000
##    180        0.0039             nan     0.0100    0.0000
##    200        0.0031             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0001
##      3        0.0423             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100    0.0002
##      5        0.0410             nan     0.0100    0.0003
##      6        0.0405             nan     0.0100    0.0002
##      7        0.0398             nan     0.0100    0.0006
##      8        0.0391             nan     0.0100    0.0006
##      9        0.0386             nan     0.0100    0.0006
##     10        0.0380             nan     0.0100    0.0003
##     20        0.0332             nan     0.0100    0.0001
##     40        0.0251             nan     0.0100    0.0004
##     60        0.0194             nan     0.0100    0.0001
##     80        0.0147             nan     0.0100    0.0002
##    100        0.0110             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0000
##    140        0.0073             nan     0.0100   -0.0000
##    160        0.0059             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0005
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0003
##      4        0.0416             nan     0.0100    0.0006
##      5        0.0412             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0002
##      7        0.0403             nan     0.0100    0.0006
##      8        0.0400             nan     0.0100    0.0001
##      9        0.0394             nan     0.0100    0.0005
##     10        0.0389             nan     0.0100    0.0005
##     20        0.0349             nan     0.0100    0.0004
##     40        0.0279             nan     0.0100    0.0001
##     60        0.0223             nan     0.0100    0.0002
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0154             nan     0.0100    0.0000
##    120        0.0129             nan     0.0100    0.0001
##    140        0.0110             nan     0.0100    0.0000
##    160        0.0096             nan     0.0100    0.0000
##    180        0.0087             nan     0.0100    0.0001
##    200        0.0076             nan     0.0100    0.0000
## 
## - Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0419             nan     0.0500    0.0017
##      2        0.0389             nan     0.0500    0.0018
##      3        0.0365             nan     0.0500    0.0024
##      4        0.0348             nan     0.0500    0.0016
##      5        0.0342             nan     0.0500    0.0000
##      6        0.0325             nan     0.0500    0.0014
##      7        0.0309             nan     0.0500    0.0010
##      8        0.0286             nan     0.0500    0.0020
##      9        0.0274             nan     0.0500    0.0006
##     10        0.0262             nan     0.0500    0.0008
##     20        0.0140             nan     0.0500    0.0006
##     40        0.0058             nan     0.0500    0.0002
##     60        0.0026             nan     0.0500    0.0001
##     80        0.0014             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0023
##      2        0.0384             nan     0.0500    0.0022
##      3        0.0366             nan     0.0500    0.0008
##      4        0.0353             nan     0.0500    0.0005
##      5        0.0349             nan     0.0500   -0.0022
##      6        0.0330             nan     0.0500    0.0019
##      7        0.0304             nan     0.0500    0.0024
##      8        0.0291             nan     0.0500    0.0013
##      9        0.0268             nan     0.0500    0.0018
##     10        0.0253             nan     0.0500    0.0012
##     20        0.0145             nan     0.0500    0.0005
##     40        0.0065             nan     0.0500    0.0003
##     60        0.0027             nan     0.0500    0.0001
##     80        0.0017             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0025
##      2        0.0376             nan     0.0500    0.0025
##      3        0.0355             nan     0.0500    0.0021
##      4        0.0337             nan     0.0500    0.0014
##      5        0.0320             nan     0.0500    0.0016
##      6        0.0306             nan     0.0500    0.0016
##      7        0.0299             nan     0.0500    0.0001
##      8        0.0283             nan     0.0500    0.0016
##      9        0.0270             nan     0.0500    0.0010
##     10        0.0256             nan     0.0500    0.0014
##     20        0.0164             nan     0.0500    0.0003
##     40        0.0081             nan     0.0500    0.0002
##     60        0.0047             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500   -0.0000
##    100        0.0024             nan     0.0500    0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0500    0.0039
##      2        0.0384             nan     0.0500    0.0016
##      3        0.0366             nan     0.0500    0.0019
##      4        0.0339             nan     0.0500    0.0026
##      5        0.0316             nan     0.0500    0.0017
##      6        0.0299             nan     0.0500    0.0003
##      7        0.0289             nan     0.0500   -0.0000
##      8        0.0276             nan     0.0500    0.0012
##      9        0.0255             nan     0.0500    0.0013
##     10        0.0232             nan     0.0500    0.0017
##     20        0.0138             nan     0.0500    0.0005
##     40        0.0039             nan     0.0500    0.0002
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0041
##      2        0.0377             nan     0.0500    0.0024
##      3        0.0362             nan     0.0500    0.0013
##      4        0.0344             nan     0.0500    0.0010
##      5        0.0315             nan     0.0500    0.0024
##      6        0.0293             nan     0.0500    0.0022
##      7        0.0278             nan     0.0500    0.0005
##      8        0.0264             nan     0.0500    0.0014
##      9        0.0239             nan     0.0500    0.0017
##     10        0.0221             nan     0.0500    0.0015
##     20        0.0114             nan     0.0500    0.0007
##     40        0.0039             nan     0.0500    0.0002
##     60        0.0017             nan     0.0500    0.0001
##     80        0.0010             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0026
##      2        0.0376             nan     0.0500    0.0024
##      3        0.0350             nan     0.0500    0.0024
##      4        0.0333             nan     0.0500    0.0003
##      5        0.0312             nan     0.0500    0.0016
##      6        0.0302             nan     0.0500    0.0003
##      7        0.0280             nan     0.0500    0.0014
##      8        0.0263             nan     0.0500    0.0016
##      9        0.0254             nan     0.0500    0.0009
##     10        0.0250             nan     0.0500    0.0001
##     20        0.0157             nan     0.0500    0.0006
##     40        0.0092             nan     0.0500   -0.0001
##     60        0.0053             nan     0.0500    0.0001
##     80        0.0034             nan     0.0500   -0.0000
##    100        0.0022             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0400             nan     0.0500    0.0029
##      2        0.0372             nan     0.0500    0.0034
##      3        0.0348             nan     0.0500    0.0017
##      4        0.0333             nan     0.0500    0.0006
##      5        0.0310             nan     0.0500    0.0014
##      6        0.0290             nan     0.0500    0.0016
##      7        0.0272             nan     0.0500    0.0008
##      8        0.0256             nan     0.0500    0.0012
##      9        0.0233             nan     0.0500    0.0021
##     10        0.0221             nan     0.0500    0.0011
##     20        0.0103             nan     0.0500    0.0006
##     40        0.0030             nan     0.0500   -0.0000
##     60        0.0009             nan     0.0500   -0.0000
##     80        0.0004             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0419             nan     0.0500    0.0001
##      2        0.0384             nan     0.0500    0.0030
##      3        0.0374             nan     0.0500   -0.0001
##      4        0.0340             nan     0.0500    0.0018
##      5        0.0325             nan     0.0500    0.0010
##      6        0.0313             nan     0.0500    0.0008
##      7        0.0287             nan     0.0500    0.0012
##      8        0.0269             nan     0.0500    0.0014
##      9        0.0244             nan     0.0500    0.0021
##     10        0.0226             nan     0.0500    0.0016
##     20        0.0104             nan     0.0500    0.0007
##     40        0.0034             nan     0.0500   -0.0000
##     60        0.0015             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0019
##      2        0.0394             nan     0.0500    0.0027
##      3        0.0360             nan     0.0500    0.0023
##      4        0.0338             nan     0.0500    0.0018
##      5        0.0314             nan     0.0500    0.0018
##      6        0.0295             nan     0.0500    0.0020
##      7        0.0280             nan     0.0500    0.0014
##      8        0.0261             nan     0.0500    0.0014
##      9        0.0248             nan     0.0500    0.0010
##     10        0.0240             nan     0.0500    0.0005
##     20        0.0160             nan     0.0500    0.0005
##     40        0.0085             nan     0.0500    0.0002
##     60        0.0054             nan     0.0500   -0.0000
##     80        0.0036             nan     0.0500   -0.0000
##    100        0.0025             nan     0.0500   -0.0000
##    120        0.0019             nan     0.0500   -0.0001
##    140        0.0014             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0051
##      2        0.0333             nan     0.1000    0.0036
##      3        0.0306             nan     0.1000    0.0025
##      4        0.0255             nan     0.1000    0.0022
##      5        0.0221             nan     0.1000    0.0005
##      6        0.0197             nan     0.1000    0.0022
##      7        0.0172             nan     0.1000    0.0016
##      8        0.0151             nan     0.1000    0.0010
##      9        0.0134             nan     0.1000    0.0015
##     10        0.0126             nan     0.1000    0.0007
##     20        0.0053             nan     0.1000    0.0001
##     40        0.0011             nan     0.1000    0.0000
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0053
##      2        0.0342             nan     0.1000    0.0025
##      3        0.0306             nan     0.1000    0.0032
##      4        0.0260             nan     0.1000    0.0029
##      5        0.0222             nan     0.1000    0.0036
##      6        0.0199             nan     0.1000    0.0016
##      7        0.0179             nan     0.1000    0.0019
##      8        0.0160             nan     0.1000    0.0009
##      9        0.0142             nan     0.1000    0.0014
##     10        0.0128             nan     0.1000    0.0008
##     20        0.0059             nan     0.1000    0.0002
##     40        0.0015             nan     0.1000    0.0000
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0057
##      2        0.0330             nan     0.1000    0.0044
##      3        0.0298             nan     0.1000    0.0034
##      4        0.0267             nan     0.1000    0.0030
##      5        0.0231             nan     0.1000    0.0020
##      6        0.0213             nan     0.1000    0.0016
##      7        0.0203             nan     0.1000   -0.0006
##      8        0.0175             nan     0.1000    0.0005
##      9        0.0162             nan     0.1000    0.0010
##     10        0.0156             nan     0.1000    0.0005
##     20        0.0081             nan     0.1000   -0.0002
##     40        0.0035             nan     0.1000   -0.0002
##     60        0.0019             nan     0.1000   -0.0001
##     80        0.0010             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.1000    0.0039
##      2        0.0338             nan     0.1000    0.0042
##      3        0.0306             nan     0.1000    0.0012
##      4        0.0262             nan     0.1000    0.0046
##      5        0.0225             nan     0.1000    0.0030
##      6        0.0188             nan     0.1000    0.0028
##      7        0.0168             nan     0.1000    0.0014
##      8        0.0150             nan     0.1000    0.0011
##      9        0.0128             nan     0.1000    0.0016
##     10        0.0120             nan     0.1000    0.0003
##     20        0.0047             nan     0.1000    0.0001
##     40        0.0010             nan     0.1000    0.0001
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0060
##      2        0.0323             nan     0.1000    0.0023
##      3        0.0280             nan     0.1000    0.0038
##      4        0.0240             nan     0.1000    0.0028
##      5        0.0213             nan     0.1000    0.0015
##      6        0.0192             nan     0.1000    0.0019
##      7        0.0164             nan     0.1000    0.0025
##      8        0.0151             nan     0.1000    0.0007
##      9        0.0139             nan     0.1000    0.0003
##     10        0.0122             nan     0.1000    0.0012
##     20        0.0041             nan     0.1000    0.0001
##     40        0.0010             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0057
##      2        0.0343             nan     0.1000    0.0028
##      3        0.0301             nan     0.1000    0.0017
##      4        0.0263             nan     0.1000    0.0038
##      5        0.0231             nan     0.1000    0.0023
##      6        0.0205             nan     0.1000    0.0018
##      7        0.0188             nan     0.1000    0.0016
##      8        0.0163             nan     0.1000    0.0006
##      9        0.0151             nan     0.1000    0.0012
##     10        0.0142             nan     0.1000    0.0002
##     20        0.0072             nan     0.1000    0.0003
##     40        0.0036             nan     0.1000    0.0001
##     60        0.0015             nan     0.1000   -0.0002
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0032
##      2        0.0329             nan     0.1000    0.0058
##      3        0.0306             nan     0.1000    0.0017
##      4        0.0247             nan     0.1000    0.0027
##      5        0.0213             nan     0.1000    0.0023
##      6        0.0180             nan     0.1000    0.0030
##      7        0.0161             nan     0.1000    0.0019
##      8        0.0142             nan     0.1000    0.0009
##      9        0.0123             nan     0.1000   -0.0003
##     10        0.0105             nan     0.1000    0.0011
##     20        0.0033             nan     0.1000    0.0002
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0056
##      2        0.0315             nan     0.1000    0.0032
##      3        0.0285             nan     0.1000    0.0031
##      4        0.0234             nan     0.1000    0.0045
##      5        0.0209             nan     0.1000    0.0024
##      6        0.0190             nan     0.1000    0.0020
##      7        0.0161             nan     0.1000    0.0024
##      8        0.0136             nan     0.1000    0.0018
##      9        0.0114             nan     0.1000    0.0016
##     10        0.0098             nan     0.1000    0.0014
##     20        0.0028             nan     0.1000    0.0000
##     40        0.0006             nan     0.1000   -0.0001
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0052
##      2        0.0325             nan     0.1000    0.0041
##      3        0.0284             nan     0.1000    0.0023
##      4        0.0251             nan     0.1000    0.0033
##      5        0.0229             nan     0.1000    0.0025
##      6        0.0208             nan     0.1000    0.0021
##      7        0.0195             nan     0.1000    0.0013
##      8        0.0172             nan     0.1000    0.0019
##      9        0.0157             nan     0.1000    0.0016
##     10        0.0149             nan     0.1000    0.0002
##     20        0.0086             nan     0.1000   -0.0005
##     40        0.0034             nan     0.1000   -0.0001
##     60        0.0018             nan     0.1000   -0.0001
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000    0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100    0.0002
##      2        0.0424             nan     0.0100    0.0005
##      3        0.0421             nan     0.0100    0.0001
##      4        0.0415             nan     0.0100    0.0002
##      5        0.0410             nan     0.0100    0.0005
##      6        0.0405             nan     0.0100    0.0005
##      7        0.0400             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0002
##      9        0.0389             nan     0.0100    0.0005
##     10        0.0385             nan     0.0100    0.0002
##     20        0.0345             nan     0.0100    0.0003
##     40        0.0270             nan     0.0100    0.0003
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0178             nan     0.0100   -0.0001
##    100        0.0144             nan     0.0100    0.0001
##    120        0.0119             nan     0.0100    0.0001
##    140        0.0098             nan     0.0100    0.0001
##    160        0.0082             nan     0.0100    0.0001
##    180        0.0069             nan     0.0100    0.0001
##    200        0.0057             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0005
##      2        0.0422             nan     0.0100    0.0006
##      3        0.0415             nan     0.0100    0.0006
##      4        0.0411             nan     0.0100    0.0001
##      5        0.0406             nan     0.0100    0.0003
##      6        0.0401             nan     0.0100    0.0003
##      7        0.0396             nan     0.0100    0.0002
##      8        0.0394             nan     0.0100   -0.0000
##      9        0.0388             nan     0.0100    0.0005
##     10        0.0383             nan     0.0100    0.0005
##     20        0.0344             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100    0.0001
##     60        0.0227             nan     0.0100   -0.0000
##     80        0.0184             nan     0.0100    0.0002
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0123             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100   -0.0000
##    160        0.0085             nan     0.0100    0.0000
##    180        0.0073             nan     0.0100   -0.0000
##    200        0.0062             nan     0.0100    0.0001
## 
## - Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0004
##      2        0.0423             nan     0.0100    0.0004
##      3        0.0419             nan     0.0100    0.0004
##      4        0.0415             nan     0.0100    0.0003
##      5        0.0411             nan     0.0100    0.0005
##      6        0.0404             nan     0.0100    0.0005
##      7        0.0398             nan     0.0100    0.0005
##      8        0.0397             nan     0.0100   -0.0002
##      9        0.0394             nan     0.0100    0.0002
##     10        0.0391             nan     0.0100    0.0003
##     20        0.0347             nan     0.0100    0.0001
##     40        0.0279             nan     0.0100    0.0002
##     60        0.0229             nan     0.0100    0.0001
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0000
##    120        0.0142             nan     0.0100    0.0001
##    140        0.0123             nan     0.0100    0.0001
##    160        0.0109             nan     0.0100    0.0001
##    180        0.0095             nan     0.0100    0.0000
##    200        0.0086             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0003
##      2        0.0422             nan     0.0100    0.0006
##      3        0.0418             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100   -0.0001
##      5        0.0409             nan     0.0100    0.0004
##      6        0.0402             nan     0.0100    0.0006
##      7        0.0395             nan     0.0100    0.0004
##      8        0.0390             nan     0.0100    0.0004
##      9        0.0386             nan     0.0100    0.0001
##     10        0.0381             nan     0.0100    0.0004
##     20        0.0325             nan     0.0100    0.0002
##     40        0.0252             nan     0.0100    0.0003
##     60        0.0194             nan     0.0100    0.0001
##     80        0.0151             nan     0.0100    0.0000
##    100        0.0118             nan     0.0100    0.0001
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0001
##    160        0.0059             nan     0.0100    0.0000
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0004
##      2        0.0423             nan     0.0100    0.0004
##      3        0.0415             nan     0.0100    0.0006
##      4        0.0410             nan     0.0100    0.0004
##      5        0.0405             nan     0.0100    0.0002
##      6        0.0401             nan     0.0100    0.0005
##      7        0.0396             nan     0.0100    0.0005
##      8        0.0390             nan     0.0100    0.0006
##      9        0.0385             nan     0.0100    0.0005
##     10        0.0379             nan     0.0100    0.0006
##     20        0.0331             nan     0.0100    0.0004
##     40        0.0260             nan     0.0100    0.0002
##     60        0.0203             nan     0.0100    0.0002
##     80        0.0157             nan     0.0100    0.0002
##    100        0.0124             nan     0.0100    0.0001
##    120        0.0102             nan     0.0100    0.0001
##    140        0.0084             nan     0.0100   -0.0000
##    160        0.0068             nan     0.0100    0.0001
##    180        0.0057             nan     0.0100   -0.0000
##    200        0.0047             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0004
##      2        0.0424             nan     0.0100    0.0002
##      3        0.0418             nan     0.0100    0.0005
##      4        0.0413             nan     0.0100    0.0002
##      5        0.0408             nan     0.0100    0.0005
##      6        0.0403             nan     0.0100    0.0005
##      7        0.0400             nan     0.0100    0.0002
##      8        0.0395             nan     0.0100    0.0004
##      9        0.0389             nan     0.0100    0.0003
##     10        0.0384             nan     0.0100    0.0005
##     20        0.0343             nan     0.0100    0.0002
##     40        0.0273             nan     0.0100    0.0002
##     60        0.0225             nan     0.0100    0.0002
##     80        0.0187             nan     0.0100    0.0002
##    100        0.0159             nan     0.0100    0.0001
##    120        0.0134             nan     0.0100    0.0000
##    140        0.0116             nan     0.0100    0.0000
##    160        0.0103             nan     0.0100   -0.0000
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100   -0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0430             nan     0.0100   -0.0000
##      2        0.0425             nan     0.0100    0.0003
##      3        0.0418             nan     0.0100    0.0003
##      4        0.0411             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0004
##      6        0.0403             nan     0.0100    0.0002
##      7        0.0396             nan     0.0100    0.0006
##      8        0.0389             nan     0.0100    0.0007
##      9        0.0382             nan     0.0100    0.0005
##     10        0.0375             nan     0.0100    0.0004
##     20        0.0322             nan     0.0100    0.0005
##     40        0.0232             nan     0.0100    0.0003
##     60        0.0174             nan     0.0100    0.0002
##     80        0.0137             nan     0.0100    0.0001
##    100        0.0104             nan     0.0100    0.0002
##    120        0.0081             nan     0.0100    0.0001
##    140        0.0062             nan     0.0100    0.0001
##    160        0.0049             nan     0.0100    0.0000
##    180        0.0038             nan     0.0100    0.0000
##    200        0.0031             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0002
##      2        0.0422             nan     0.0100    0.0003
##      3        0.0417             nan     0.0100    0.0005
##      4        0.0410             nan     0.0100    0.0003
##      5        0.0407             nan     0.0100    0.0001
##      6        0.0404             nan     0.0100    0.0001
##      7        0.0400             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100    0.0000
##      9        0.0391             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0004
##     20        0.0339             nan     0.0100    0.0005
##     40        0.0255             nan     0.0100    0.0001
##     60        0.0196             nan     0.0100    0.0002
##     80        0.0154             nan     0.0100   -0.0001
##    100        0.0124             nan     0.0100   -0.0000
##    120        0.0099             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0001
##    160        0.0063             nan     0.0100   -0.0000
##    180        0.0054             nan     0.0100    0.0000
##    200        0.0046             nan     0.0100   -0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0003
##      2        0.0422             nan     0.0100    0.0004
##      3        0.0416             nan     0.0100    0.0005
##      4        0.0411             nan     0.0100    0.0004
##      5        0.0403             nan     0.0100    0.0005
##      6        0.0398             nan     0.0100    0.0003
##      7        0.0394             nan     0.0100    0.0002
##      8        0.0390             nan     0.0100    0.0005
##      9        0.0385             nan     0.0100    0.0001
##     10        0.0381             nan     0.0100    0.0005
##     20        0.0342             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100    0.0001
##     60        0.0228             nan     0.0100    0.0001
##     80        0.0185             nan     0.0100    0.0002
##    100        0.0156             nan     0.0100   -0.0000
##    120        0.0133             nan     0.0100    0.0000
##    140        0.0116             nan     0.0100   -0.0000
##    160        0.0102             nan     0.0100    0.0001
##    180        0.0092             nan     0.0100   -0.0000
##    200        0.0081             nan     0.0100    0.0000
## 
## - Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0419             nan     0.0500    0.0006
##      2        0.0397             nan     0.0500    0.0009
##      3        0.0368             nan     0.0500    0.0029
##      4        0.0342             nan     0.0500    0.0024
##      5        0.0319             nan     0.0500    0.0020
##      6        0.0303             nan     0.0500    0.0014
##      7        0.0285             nan     0.0500    0.0017
##      8        0.0267             nan     0.0500    0.0011
##      9        0.0254             nan     0.0500    0.0011
##     10        0.0237             nan     0.0500    0.0020
##     20        0.0152             nan     0.0500    0.0000
##     40        0.0062             nan     0.0500    0.0001
##     60        0.0027             nan     0.0500   -0.0000
##     80        0.0014             nan     0.0500   -0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0006
##      2        0.0398             nan     0.0500    0.0020
##      3        0.0381             nan     0.0500    0.0006
##      4        0.0361             nan     0.0500    0.0002
##      5        0.0339             nan     0.0500    0.0020
##      6        0.0310             nan     0.0500    0.0021
##      7        0.0303             nan     0.0500    0.0001
##      8        0.0288             nan     0.0500    0.0011
##      9        0.0272             nan     0.0500    0.0006
##     10        0.0254             nan     0.0500    0.0004
##     20        0.0153             nan     0.0500    0.0003
##     40        0.0066             nan     0.0500    0.0001
##     60        0.0034             nan     0.0500   -0.0000
##     80        0.0021             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500    0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0017
##      2        0.0394             nan     0.0500    0.0014
##      3        0.0369             nan     0.0500    0.0019
##      4        0.0345             nan     0.0500    0.0011
##      5        0.0327             nan     0.0500    0.0015
##      6        0.0305             nan     0.0500    0.0021
##      7        0.0291             nan     0.0500    0.0015
##      8        0.0272             nan     0.0500    0.0016
##      9        0.0255             nan     0.0500    0.0013
##     10        0.0245             nan     0.0500    0.0011
##     20        0.0160             nan     0.0500    0.0004
##     40        0.0081             nan     0.0500    0.0001
##     60        0.0051             nan     0.0500    0.0001
##     80        0.0037             nan     0.0500    0.0001
##    100        0.0024             nan     0.0500   -0.0000
##    120        0.0014             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500   -0.0000
##      2        0.0385             nan     0.0500    0.0024
##      3        0.0372             nan     0.0500   -0.0000
##      4        0.0339             nan     0.0500    0.0032
##      5        0.0323             nan     0.0500    0.0013
##      6        0.0309             nan     0.0500    0.0006
##      7        0.0290             nan     0.0500    0.0015
##      8        0.0273             nan     0.0500    0.0015
##      9        0.0262             nan     0.0500    0.0000
##     10        0.0243             nan     0.0500    0.0020
##     20        0.0130             nan     0.0500    0.0003
##     40        0.0040             nan     0.0500    0.0002
##     60        0.0015             nan     0.0500    0.0000
##     80        0.0006             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.0500    0.0036
##      2        0.0375             nan     0.0500    0.0007
##      3        0.0350             nan     0.0500    0.0029
##      4        0.0328             nan     0.0500    0.0018
##      5        0.0310             nan     0.0500    0.0019
##      6        0.0287             nan     0.0500    0.0017
##      7        0.0270             nan     0.0500    0.0012
##      8        0.0255             nan     0.0500    0.0018
##      9        0.0251             nan     0.0500    0.0000
##     10        0.0238             nan     0.0500    0.0001
##     20        0.0135             nan     0.0500    0.0009
##     40        0.0056             nan     0.0500    0.0001
##     60        0.0026             nan     0.0500    0.0000
##     80        0.0012             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0025
##      2        0.0381             nan     0.0500    0.0025
##      3        0.0366             nan     0.0500    0.0010
##      4        0.0349             nan     0.0500    0.0015
##      5        0.0335             nan     0.0500    0.0008
##      6        0.0317             nan     0.0500    0.0016
##      7        0.0305             nan     0.0500    0.0001
##      8        0.0298             nan     0.0500   -0.0001
##      9        0.0287             nan     0.0500    0.0009
##     10        0.0274             nan     0.0500    0.0012
##     20        0.0171             nan     0.0500    0.0008
##     40        0.0091             nan     0.0500    0.0000
##     60        0.0054             nan     0.0500    0.0001
##     80        0.0036             nan     0.0500    0.0001
##    100        0.0024             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0018
##      2        0.0373             nan     0.0500    0.0014
##      3        0.0338             nan     0.0500    0.0019
##      4        0.0310             nan     0.0500    0.0021
##      5        0.0293             nan     0.0500    0.0020
##      6        0.0279             nan     0.0500    0.0014
##      7        0.0263             nan     0.0500    0.0004
##      8        0.0242             nan     0.0500    0.0015
##      9        0.0228             nan     0.0500    0.0014
##     10        0.0213             nan     0.0500    0.0009
##     20        0.0115             nan     0.0500    0.0002
##     40        0.0032             nan     0.0500    0.0000
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.0500    0.0028
##      2        0.0371             nan     0.0500    0.0026
##      3        0.0356             nan     0.0500    0.0005
##      4        0.0328             nan     0.0500    0.0025
##      5        0.0302             nan     0.0500    0.0019
##      6        0.0279             nan     0.0500    0.0020
##      7        0.0258             nan     0.0500    0.0011
##      8        0.0244             nan     0.0500    0.0005
##      9        0.0237             nan     0.0500   -0.0002
##     10        0.0220             nan     0.0500    0.0009
##     20        0.0111             nan     0.0500    0.0000
##     40        0.0041             nan     0.0500    0.0002
##     60        0.0016             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0029
##      2        0.0378             nan     0.0500    0.0020
##      3        0.0356             nan     0.0500    0.0025
##      4        0.0337             nan     0.0500    0.0014
##      5        0.0316             nan     0.0500    0.0018
##      6        0.0299             nan     0.0500    0.0007
##      7        0.0279             nan     0.0500    0.0016
##      8        0.0263             nan     0.0500    0.0008
##      9        0.0249             nan     0.0500    0.0013
##     10        0.0232             nan     0.0500    0.0005
##     20        0.0160             nan     0.0500   -0.0003
##     40        0.0076             nan     0.0500    0.0001
##     60        0.0046             nan     0.0500    0.0001
##     80        0.0031             nan     0.0500    0.0001
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.1000    0.0046
##      2        0.0336             nan     0.1000    0.0043
##      3        0.0300             nan     0.1000    0.0020
##      4        0.0260             nan     0.1000    0.0026
##      5        0.0238             nan     0.1000    0.0003
##      6        0.0218             nan     0.1000    0.0017
##      7        0.0198             nan     0.1000    0.0004
##      8        0.0177             nan     0.1000    0.0014
##      9        0.0160             nan     0.1000    0.0007
##     10        0.0149             nan     0.1000   -0.0007
##     20        0.0056             nan     0.1000    0.0003
##     40        0.0015             nan     0.1000    0.0001
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.1000    0.0049
##      2        0.0368             nan     0.1000   -0.0008
##      3        0.0323             nan     0.1000    0.0009
##      4        0.0286             nan     0.1000    0.0038
##      5        0.0254             nan     0.1000    0.0028
##      6        0.0224             nan     0.1000    0.0032
##      7        0.0200             nan     0.1000    0.0021
##      8        0.0182             nan     0.1000    0.0010
##      9        0.0167             nan     0.1000    0.0009
##     10        0.0151             nan     0.1000    0.0014
##     20        0.0064             nan     0.1000    0.0003
##     40        0.0023             nan     0.1000    0.0001
##     60        0.0009             nan     0.1000    0.0000
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000    0.0011
##      2        0.0334             nan     0.1000    0.0036
##      3        0.0291             nan     0.1000    0.0043
##      4        0.0260             nan     0.1000    0.0029
##      5        0.0234             nan     0.1000    0.0008
##      6        0.0208             nan     0.1000    0.0025
##      7        0.0193             nan     0.1000    0.0007
##      8        0.0177             nan     0.1000    0.0014
##      9        0.0150             nan     0.1000    0.0008
##     10        0.0136             nan     0.1000    0.0014
##     20        0.0085             nan     0.1000    0.0006
##     40        0.0034             nan     0.1000   -0.0001
##     60        0.0011             nan     0.1000   -0.0001
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0048
##      2        0.0331             nan     0.1000    0.0049
##      3        0.0293             nan     0.1000    0.0017
##      4        0.0241             nan     0.1000    0.0048
##      5        0.0211             nan     0.1000    0.0029
##      6        0.0195             nan     0.1000    0.0015
##      7        0.0173             nan     0.1000    0.0006
##      8        0.0156             nan     0.1000   -0.0003
##      9        0.0136             nan     0.1000    0.0015
##     10        0.0120             nan     0.1000    0.0015
##     20        0.0050             nan     0.1000    0.0001
##     40        0.0013             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0038
##      2        0.0321             nan     0.1000    0.0036
##      3        0.0268             nan     0.1000    0.0040
##      4        0.0246             nan     0.1000    0.0025
##      5        0.0225             nan     0.1000    0.0021
##      6        0.0196             nan     0.1000    0.0004
##      7        0.0174             nan     0.1000    0.0017
##      8        0.0157             nan     0.1000    0.0017
##      9        0.0132             nan     0.1000    0.0022
##     10        0.0122             nan     0.1000    0.0010
##     20        0.0041             nan     0.1000    0.0001
##     40        0.0011             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0049
##      2        0.0345             nan     0.1000    0.0003
##      3        0.0315             nan     0.1000    0.0013
##      4        0.0291             nan     0.1000    0.0002
##      5        0.0265             nan     0.1000    0.0021
##      6        0.0241             nan     0.1000    0.0016
##      7        0.0214             nan     0.1000    0.0025
##      8        0.0189             nan     0.1000    0.0018
##      9        0.0174             nan     0.1000    0.0014
##     10        0.0160             nan     0.1000    0.0014
##     20        0.0094             nan     0.1000    0.0003
##     40        0.0038             nan     0.1000   -0.0001
##     60        0.0016             nan     0.1000   -0.0001
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.1000    0.0027
##      2        0.0338             nan     0.1000    0.0040
##      3        0.0275             nan     0.1000    0.0059
##      4        0.0238             nan     0.1000    0.0021
##      5        0.0210             nan     0.1000    0.0019
##      6        0.0200             nan     0.1000   -0.0010
##      7        0.0172             nan     0.1000    0.0027
##      8        0.0146             nan     0.1000    0.0013
##      9        0.0123             nan     0.1000    0.0016
##     10        0.0104             nan     0.1000    0.0019
##     20        0.0036             nan     0.1000   -0.0001
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0054
##      2        0.0312             nan     0.1000    0.0028
##      3        0.0249             nan     0.1000    0.0044
##      4        0.0206             nan     0.1000    0.0031
##      5        0.0184             nan     0.1000    0.0023
##      6        0.0170             nan     0.1000    0.0008
##      7        0.0163             nan     0.1000   -0.0012
##      8        0.0141             nan     0.1000    0.0007
##      9        0.0119             nan     0.1000    0.0015
##     10        0.0111             nan     0.1000    0.0001
##     20        0.0042             nan     0.1000   -0.0000
##     40        0.0008             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0044
##      2        0.0326             nan     0.1000    0.0036
##      3        0.0294             nan     0.1000    0.0027
##      4        0.0258             nan     0.1000    0.0028
##      5        0.0252             nan     0.1000   -0.0001
##      6        0.0224             nan     0.1000    0.0014
##      7        0.0203             nan     0.1000    0.0021
##      8        0.0186             nan     0.1000    0.0014
##      9        0.0173             nan     0.1000    0.0016
##     10        0.0155             nan     0.1000   -0.0000
##     20        0.0079             nan     0.1000    0.0004
##     40        0.0028             nan     0.1000    0.0001
##     60        0.0013             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0004
##      2        0.0421             nan     0.0100   -0.0000
##      3        0.0414             nan     0.0100    0.0005
##      4        0.0408             nan     0.0100    0.0006
##      5        0.0405             nan     0.0100    0.0004
##      6        0.0400             nan     0.0100    0.0006
##      7        0.0393             nan     0.0100    0.0005
##      8        0.0388             nan     0.0100    0.0005
##      9        0.0383             nan     0.0100    0.0005
##     10        0.0379             nan     0.0100    0.0001
##     20        0.0338             nan     0.0100    0.0001
##     40        0.0271             nan     0.0100    0.0000
##     60        0.0221             nan     0.0100    0.0003
##     80        0.0178             nan     0.0100    0.0002
##    100        0.0149             nan     0.0100   -0.0000
##    120        0.0124             nan     0.0100   -0.0000
##    140        0.0105             nan     0.0100    0.0000
##    160        0.0087             nan     0.0100    0.0000
##    180        0.0074             nan     0.0100    0.0001
##    200        0.0061             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0423             nan     0.0100    0.0006
##      2        0.0416             nan     0.0100    0.0004
##      3        0.0409             nan     0.0100    0.0006
##      4        0.0403             nan     0.0100    0.0004
##      5        0.0398             nan     0.0100    0.0005
##      6        0.0394             nan     0.0100    0.0005
##      7        0.0388             nan     0.0100    0.0004
##      8        0.0386             nan     0.0100   -0.0000
##      9        0.0380             nan     0.0100    0.0005
##     10        0.0375             nan     0.0100    0.0005
##     20        0.0333             nan     0.0100    0.0002
##     40        0.0269             nan     0.0100   -0.0000
##     60        0.0219             nan     0.0100    0.0002
##     80        0.0176             nan     0.0100    0.0002
##    100        0.0146             nan     0.0100    0.0000
##    120        0.0118             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0000
##    160        0.0082             nan     0.0100   -0.0000
##    180        0.0071             nan     0.0100    0.0000
##    200        0.0059             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0005
##      2        0.0419             nan     0.0100    0.0006
##      3        0.0415             nan     0.0100    0.0004
##      4        0.0409             nan     0.0100    0.0004
##      5        0.0404             nan     0.0100    0.0005
##      6        0.0398             nan     0.0100    0.0005
##      7        0.0392             nan     0.0100    0.0005
##      8        0.0387             nan     0.0100    0.0004
##      9        0.0382             nan     0.0100    0.0005
##     10        0.0378             nan     0.0100    0.0002
##     20        0.0339             nan     0.0100    0.0004
##     40        0.0273             nan     0.0100   -0.0000
##     60        0.0224             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0158             nan     0.0100    0.0000
##    120        0.0136             nan     0.0100   -0.0000
##    140        0.0117             nan     0.0100   -0.0000
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0091             nan     0.0100    0.0000
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0004
##      2        0.0421             nan     0.0100    0.0004
##      3        0.0415             nan     0.0100    0.0003
##      4        0.0408             nan     0.0100    0.0003
##      5        0.0403             nan     0.0100    0.0001
##      6        0.0397             nan     0.0100    0.0002
##      7        0.0393             nan     0.0100    0.0005
##      8        0.0386             nan     0.0100    0.0007
##      9        0.0382             nan     0.0100    0.0003
##     10        0.0377             nan     0.0100    0.0004
##     20        0.0332             nan     0.0100    0.0005
##     40        0.0252             nan     0.0100    0.0002
##     60        0.0187             nan     0.0100    0.0002
##     80        0.0146             nan     0.0100    0.0001
##    100        0.0112             nan     0.0100    0.0002
##    120        0.0088             nan     0.0100    0.0000
##    140        0.0070             nan     0.0100   -0.0000
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100    0.0000
##    200        0.0038             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0005
##      2        0.0420             nan     0.0100    0.0001
##      3        0.0414             nan     0.0100    0.0006
##      4        0.0408             nan     0.0100    0.0004
##      5        0.0402             nan     0.0100    0.0004
##      6        0.0397             nan     0.0100    0.0004
##      7        0.0391             nan     0.0100    0.0006
##      8        0.0387             nan     0.0100    0.0003
##      9        0.0382             nan     0.0100    0.0005
##     10        0.0375             nan     0.0100    0.0006
##     20        0.0321             nan     0.0100    0.0003
##     40        0.0248             nan     0.0100    0.0001
##     60        0.0198             nan     0.0100    0.0001
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0102             nan     0.0100    0.0000
##    140        0.0083             nan     0.0100    0.0000
##    160        0.0068             nan     0.0100    0.0000
##    180        0.0055             nan     0.0100    0.0000
##    200        0.0047             nan     0.0100   -0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0004
##      2        0.0420             nan     0.0100    0.0005
##      3        0.0416             nan     0.0100    0.0003
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0405             nan     0.0100    0.0006
##      6        0.0400             nan     0.0100    0.0003
##      7        0.0395             nan     0.0100    0.0006
##      8        0.0389             nan     0.0100    0.0004
##      9        0.0384             nan     0.0100    0.0005
##     10        0.0380             nan     0.0100    0.0004
##     20        0.0340             nan     0.0100    0.0003
##     40        0.0274             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0000
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0160             nan     0.0100    0.0001
##    120        0.0136             nan     0.0100    0.0000
##    140        0.0118             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0093             nan     0.0100   -0.0000
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0005
##      2        0.0419             nan     0.0100    0.0001
##      3        0.0413             nan     0.0100    0.0006
##      4        0.0408             nan     0.0100    0.0004
##      5        0.0404             nan     0.0100    0.0001
##      6        0.0396             nan     0.0100    0.0008
##      7        0.0389             nan     0.0100    0.0006
##      8        0.0385             nan     0.0100   -0.0000
##      9        0.0380             nan     0.0100    0.0003
##     10        0.0375             nan     0.0100    0.0006
##     20        0.0325             nan     0.0100    0.0003
##     40        0.0240             nan     0.0100    0.0003
##     60        0.0186             nan     0.0100    0.0002
##     80        0.0141             nan     0.0100    0.0001
##    100        0.0108             nan     0.0100    0.0001
##    120        0.0082             nan     0.0100    0.0001
##    140        0.0062             nan     0.0100    0.0000
##    160        0.0048             nan     0.0100    0.0000
##    180        0.0038             nan     0.0100    0.0001
##    200        0.0031             nan     0.0100   -0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0002
##      2        0.0418             nan     0.0100    0.0006
##      3        0.0410             nan     0.0100    0.0005
##      4        0.0404             nan     0.0100    0.0007
##      5        0.0398             nan     0.0100    0.0004
##      6        0.0391             nan     0.0100    0.0004
##      7        0.0387             nan     0.0100    0.0003
##      8        0.0382             nan     0.0100    0.0001
##      9        0.0379             nan     0.0100    0.0000
##     10        0.0375             nan     0.0100    0.0002
##     20        0.0319             nan     0.0100    0.0004
##     40        0.0246             nan     0.0100    0.0003
##     60        0.0185             nan     0.0100    0.0000
##     80        0.0143             nan     0.0100    0.0000
##    100        0.0114             nan     0.0100    0.0001
##    120        0.0089             nan     0.0100    0.0000
##    140        0.0071             nan     0.0100    0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0424             nan     0.0100    0.0005
##      2        0.0422             nan     0.0100    0.0001
##      3        0.0419             nan     0.0100    0.0001
##      4        0.0413             nan     0.0100    0.0002
##      5        0.0407             nan     0.0100    0.0002
##      6        0.0402             nan     0.0100    0.0005
##      7        0.0396             nan     0.0100    0.0005
##      8        0.0393             nan     0.0100    0.0002
##      9        0.0388             nan     0.0100    0.0005
##     10        0.0384             nan     0.0100    0.0002
##     20        0.0344             nan     0.0100    0.0004
##     40        0.0280             nan     0.0100    0.0001
##     60        0.0234             nan     0.0100    0.0001
##     80        0.0193             nan     0.0100    0.0002
##    100        0.0163             nan     0.0100    0.0001
##    120        0.0140             nan     0.0100    0.0001
##    140        0.0122             nan     0.0100    0.0001
##    160        0.0104             nan     0.0100    0.0000
##    180        0.0094             nan     0.0100    0.0000
##    200        0.0085             nan     0.0100   -0.0000
## 
## - Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0500    0.0029
##      2        0.0376             nan     0.0500    0.0018
##      3        0.0347             nan     0.0500    0.0023
##      4        0.0333             nan     0.0500    0.0009
##      5        0.0314             nan     0.0500    0.0013
##      6        0.0302             nan     0.0500    0.0009
##      7        0.0297             nan     0.0500   -0.0003
##      8        0.0279             nan     0.0500    0.0007
##      9        0.0269             nan     0.0500    0.0009
##     10        0.0253             nan     0.0500    0.0014
##     20        0.0161             nan     0.0500    0.0007
##     40        0.0077             nan     0.0500   -0.0000
##     60        0.0040             nan     0.0500    0.0002
##     80        0.0021             nan     0.0500   -0.0000
##    100        0.0012             nan     0.0500    0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.0500    0.0027
##      2        0.0369             nan     0.0500    0.0017
##      3        0.0350             nan     0.0500    0.0006
##      4        0.0337             nan     0.0500   -0.0003
##      5        0.0317             nan     0.0500    0.0012
##      6        0.0303             nan     0.0500    0.0016
##      7        0.0290             nan     0.0500    0.0013
##      8        0.0276             nan     0.0500    0.0002
##      9        0.0260             nan     0.0500    0.0016
##     10        0.0253             nan     0.0500    0.0005
##     20        0.0160             nan     0.0500    0.0008
##     40        0.0069             nan     0.0500    0.0003
##     60        0.0037             nan     0.0500   -0.0001
##     80        0.0021             nan     0.0500   -0.0000
##    100        0.0013             nan     0.0500   -0.0000
##    120        0.0008             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0012
##      2        0.0396             nan     0.0500   -0.0003
##      3        0.0369             nan     0.0500    0.0023
##      4        0.0363             nan     0.0500   -0.0006
##      5        0.0337             nan     0.0500    0.0019
##      6        0.0313             nan     0.0500    0.0020
##      7        0.0296             nan     0.0500    0.0012
##      8        0.0283             nan     0.0500    0.0015
##      9        0.0271             nan     0.0500    0.0005
##     10        0.0260             nan     0.0500    0.0012
##     20        0.0163             nan     0.0500    0.0003
##     40        0.0090             nan     0.0500    0.0000
##     60        0.0048             nan     0.0500   -0.0000
##     80        0.0033             nan     0.0500   -0.0001
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0014             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0400             nan     0.0500    0.0026
##      2        0.0380             nan     0.0500    0.0016
##      3        0.0359             nan     0.0500    0.0026
##      4        0.0342             nan     0.0500    0.0014
##      5        0.0310             nan     0.0500    0.0026
##      6        0.0287             nan     0.0500    0.0016
##      7        0.0267             nan     0.0500    0.0011
##      8        0.0252             nan     0.0500    0.0011
##      9        0.0231             nan     0.0500    0.0011
##     10        0.0211             nan     0.0500    0.0016
##     20        0.0120             nan     0.0500    0.0003
##     40        0.0035             nan     0.0500    0.0001
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.0500    0.0035
##      2        0.0375             nan     0.0500    0.0020
##      3        0.0350             nan     0.0500    0.0026
##      4        0.0324             nan     0.0500    0.0021
##      5        0.0312             nan     0.0500   -0.0003
##      6        0.0294             nan     0.0500    0.0020
##      7        0.0267             nan     0.0500    0.0011
##      8        0.0252             nan     0.0500    0.0013
##      9        0.0229             nan     0.0500    0.0010
##     10        0.0208             nan     0.0500    0.0013
##     20        0.0111             nan     0.0500    0.0007
##     40        0.0045             nan     0.0500    0.0002
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500    0.0000
##    120        0.0004             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0014
##      2        0.0383             nan     0.0500    0.0016
##      3        0.0358             nan     0.0500    0.0023
##      4        0.0329             nan     0.0500    0.0015
##      5        0.0307             nan     0.0500    0.0021
##      6        0.0293             nan     0.0500    0.0010
##      7        0.0277             nan     0.0500    0.0017
##      8        0.0266             nan     0.0500    0.0006
##      9        0.0258             nan     0.0500   -0.0002
##     10        0.0247             nan     0.0500    0.0010
##     20        0.0154             nan     0.0500    0.0006
##     40        0.0080             nan     0.0500    0.0000
##     60        0.0048             nan     0.0500    0.0000
##     80        0.0032             nan     0.0500    0.0000
##    100        0.0023             nan     0.0500   -0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.0500    0.0027
##      2        0.0370             nan     0.0500    0.0026
##      3        0.0338             nan     0.0500    0.0025
##      4        0.0310             nan     0.0500    0.0017
##      5        0.0289             nan     0.0500    0.0021
##      6        0.0274             nan     0.0500    0.0010
##      7        0.0258             nan     0.0500    0.0008
##      8        0.0239             nan     0.0500    0.0013
##      9        0.0222             nan     0.0500    0.0006
##     10        0.0212             nan     0.0500    0.0001
##     20        0.0110             nan     0.0500    0.0007
##     40        0.0029             nan     0.0500    0.0000
##     60        0.0009             nan     0.0500    0.0000
##     80        0.0003             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0007
##      2        0.0392             nan     0.0500    0.0010
##      3        0.0365             nan     0.0500    0.0028
##      4        0.0336             nan     0.0500    0.0016
##      5        0.0308             nan     0.0500    0.0018
##      6        0.0287             nan     0.0500    0.0023
##      7        0.0270             nan     0.0500    0.0009
##      8        0.0256             nan     0.0500    0.0011
##      9        0.0244             nan     0.0500    0.0009
##     10        0.0232             nan     0.0500    0.0009
##     20        0.0136             nan     0.0500    0.0004
##     40        0.0047             nan     0.0500    0.0001
##     60        0.0024             nan     0.0500   -0.0001
##     80        0.0013             nan     0.0500   -0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.0500    0.0030
##      2        0.0373             nan     0.0500    0.0022
##      3        0.0342             nan     0.0500    0.0016
##      4        0.0323             nan     0.0500    0.0008
##      5        0.0307             nan     0.0500    0.0020
##      6        0.0288             nan     0.0500    0.0011
##      7        0.0274             nan     0.0500    0.0014
##      8        0.0267             nan     0.0500    0.0003
##      9        0.0255             nan     0.0500    0.0006
##     10        0.0238             nan     0.0500    0.0014
##     20        0.0135             nan     0.0500    0.0005
##     40        0.0064             nan     0.0500    0.0002
##     60        0.0037             nan     0.0500    0.0000
##     80        0.0025             nan     0.0500   -0.0000
##    100        0.0016             nan     0.0500   -0.0000
##    120        0.0011             nan     0.0500    0.0000
##    140        0.0008             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500    0.0000
## 
## - Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0052
##      2        0.0334             nan     0.1000    0.0026
##      3        0.0303             nan     0.1000    0.0028
##      4        0.0264             nan     0.1000    0.0007
##      5        0.0241             nan     0.1000    0.0013
##      6        0.0212             nan     0.1000    0.0026
##      7        0.0192             nan     0.1000   -0.0000
##      8        0.0184             nan     0.1000   -0.0001
##      9        0.0170             nan     0.1000    0.0005
##     10        0.0158             nan     0.1000    0.0008
##     20        0.0069             nan     0.1000   -0.0000
##     40        0.0016             nan     0.1000    0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0374             nan     0.1000    0.0024
##      2        0.0333             nan     0.1000    0.0030
##      3        0.0312             nan     0.1000   -0.0011
##      4        0.0281             nan     0.1000    0.0034
##      5        0.0237             nan     0.1000    0.0036
##      6        0.0213             nan     0.1000    0.0023
##      7        0.0191             nan     0.1000    0.0020
##      8        0.0167             nan     0.1000    0.0019
##      9        0.0148             nan     0.1000    0.0004
##     10        0.0133             nan     0.1000    0.0013
##     20        0.0057             nan     0.1000    0.0005
##     40        0.0020             nan     0.1000    0.0000
##     60        0.0008             nan     0.1000    0.0000
##     80        0.0004             nan     0.1000    0.0000
##    100        0.0002             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.1000    0.0029
##      2        0.0363             nan     0.1000    0.0012
##      3        0.0346             nan     0.1000   -0.0005
##      4        0.0311             nan     0.1000    0.0019
##      5        0.0272             nan     0.1000    0.0036
##      6        0.0251             nan     0.1000    0.0020
##      7        0.0218             nan     0.1000    0.0015
##      8        0.0198             nan     0.1000    0.0020
##      9        0.0178             nan     0.1000    0.0018
##     10        0.0155             nan     0.1000    0.0010
##     20        0.0091             nan     0.1000    0.0007
##     40        0.0042             nan     0.1000   -0.0000
##     60        0.0020             nan     0.1000   -0.0000
##     80        0.0011             nan     0.1000    0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0028
##      2        0.0323             nan     0.1000    0.0033
##      3        0.0274             nan     0.1000    0.0038
##      4        0.0244             nan     0.1000    0.0030
##      5        0.0211             nan     0.1000    0.0015
##      6        0.0193             nan     0.1000    0.0013
##      7        0.0168             nan     0.1000    0.0008
##      8        0.0146             nan     0.1000    0.0016
##      9        0.0127             nan     0.1000    0.0016
##     10        0.0112             nan     0.1000    0.0014
##     20        0.0032             nan     0.1000    0.0003
##     40        0.0006             nan     0.1000   -0.0001
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0052
##      2        0.0323             nan     0.1000    0.0062
##      3        0.0299             nan     0.1000   -0.0002
##      4        0.0266             nan     0.1000    0.0029
##      5        0.0237             nan     0.1000    0.0026
##      6        0.0200             nan     0.1000    0.0021
##      7        0.0180             nan     0.1000    0.0012
##      8        0.0155             nan     0.1000    0.0008
##      9        0.0140             nan     0.1000    0.0007
##     10        0.0127             nan     0.1000   -0.0003
##     20        0.0047             nan     0.1000   -0.0000
##     40        0.0015             nan     0.1000    0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.1000    0.0049
##      2        0.0348             nan     0.1000   -0.0009
##      3        0.0313             nan     0.1000    0.0040
##      4        0.0287             nan     0.1000    0.0025
##      5        0.0257             nan     0.1000    0.0031
##      6        0.0225             nan     0.1000    0.0028
##      7        0.0202             nan     0.1000    0.0015
##      8        0.0191             nan     0.1000    0.0008
##      9        0.0179             nan     0.1000    0.0015
##     10        0.0160             nan     0.1000    0.0010
##     20        0.0071             nan     0.1000   -0.0003
##     40        0.0029             nan     0.1000    0.0001
##     60        0.0013             nan     0.1000    0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0357             nan     0.1000    0.0066
##      2        0.0298             nan     0.1000    0.0060
##      3        0.0263             nan     0.1000    0.0023
##      4        0.0230             nan     0.1000    0.0032
##      5        0.0214             nan     0.1000    0.0005
##      6        0.0181             nan     0.1000    0.0022
##      7        0.0158             nan     0.1000    0.0017
##      8        0.0136             nan     0.1000    0.0017
##      9        0.0125             nan     0.1000    0.0001
##     10        0.0108             nan     0.1000    0.0003
##     20        0.0034             nan     0.1000    0.0004
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.1000    0.0046
##      2        0.0381             nan     0.1000   -0.0006
##      3        0.0332             nan     0.1000    0.0052
##      4        0.0301             nan     0.1000    0.0007
##      5        0.0272             nan     0.1000    0.0032
##      6        0.0234             nan     0.1000    0.0009
##      7        0.0215             nan     0.1000    0.0014
##      8        0.0193             nan     0.1000    0.0019
##      9        0.0173             nan     0.1000    0.0022
##     10        0.0150             nan     0.1000    0.0020
##     20        0.0054             nan     0.1000    0.0003
##     40        0.0012             nan     0.1000   -0.0001
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.1000    0.0048
##      2        0.0349             nan     0.1000   -0.0010
##      3        0.0307             nan     0.1000    0.0030
##      4        0.0273             nan     0.1000    0.0034
##      5        0.0237             nan     0.1000    0.0028
##      6        0.0224             nan     0.1000    0.0012
##      7        0.0198             nan     0.1000    0.0019
##      8        0.0178             nan     0.1000    0.0016
##      9        0.0165             nan     0.1000    0.0005
##     10        0.0158             nan     0.1000    0.0004
##     20        0.0083             nan     0.1000   -0.0000
##     40        0.0032             nan     0.1000   -0.0001
##     60        0.0016             nan     0.1000   -0.0001
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000    0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0002
##      2        0.0430             nan     0.0100    0.0004
##      3        0.0428             nan     0.0100    0.0001
##      4        0.0423             nan     0.0100    0.0001
##      5        0.0417             nan     0.0100    0.0006
##      6        0.0412             nan     0.0100    0.0004
##      7        0.0407             nan     0.0100    0.0004
##      8        0.0403             nan     0.0100    0.0005
##      9        0.0398             nan     0.0100    0.0002
##     10        0.0392             nan     0.0100    0.0005
##     20        0.0354             nan     0.0100    0.0004
##     40        0.0282             nan     0.0100    0.0003
##     60        0.0223             nan     0.0100    0.0003
##     80        0.0180             nan     0.0100    0.0002
##    100        0.0148             nan     0.0100    0.0000
##    120        0.0121             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0000
##    160        0.0087             nan     0.0100    0.0000
##    180        0.0072             nan     0.0100    0.0000
##    200        0.0060             nan     0.0100    0.0001
## 
## - Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0007
##      3        0.0422             nan     0.0100    0.0004
##      4        0.0417             nan     0.0100    0.0006
##      5        0.0411             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0004
##      7        0.0405             nan     0.0100    0.0002
##      8        0.0398             nan     0.0100    0.0006
##      9        0.0393             nan     0.0100    0.0004
##     10        0.0387             nan     0.0100    0.0002
##     20        0.0348             nan     0.0100    0.0003
##     40        0.0275             nan     0.0100    0.0003
##     60        0.0219             nan     0.0100    0.0002
##     80        0.0179             nan     0.0100   -0.0001
##    100        0.0145             nan     0.0100    0.0002
##    120        0.0119             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0001
##    160        0.0084             nan     0.0100    0.0001
##    180        0.0071             nan     0.0100   -0.0000
##    200        0.0060             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0005
##      2        0.0432             nan     0.0100   -0.0004
##      3        0.0426             nan     0.0100    0.0002
##      4        0.0420             nan     0.0100    0.0006
##      5        0.0417             nan     0.0100    0.0002
##      6        0.0413             nan     0.0100    0.0003
##      7        0.0409             nan     0.0100    0.0002
##      8        0.0404             nan     0.0100    0.0005
##      9        0.0400             nan     0.0100    0.0004
##     10        0.0395             nan     0.0100    0.0005
##     20        0.0349             nan     0.0100    0.0005
##     40        0.0281             nan     0.0100    0.0004
##     60        0.0226             nan     0.0100    0.0002
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0164             nan     0.0100    0.0001
##    120        0.0140             nan     0.0100    0.0001
##    140        0.0120             nan     0.0100    0.0001
##    160        0.0105             nan     0.0100    0.0001
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0002
##      2        0.0428             nan     0.0100    0.0004
##      3        0.0422             nan     0.0100    0.0002
##      4        0.0413             nan     0.0100    0.0009
##      5        0.0408             nan     0.0100   -0.0001
##      6        0.0401             nan     0.0100    0.0002
##      7        0.0396             nan     0.0100    0.0004
##      8        0.0389             nan     0.0100    0.0004
##      9        0.0383             nan     0.0100    0.0006
##     10        0.0377             nan     0.0100    0.0003
##     20        0.0332             nan     0.0100    0.0003
##     40        0.0254             nan     0.0100    0.0003
##     60        0.0196             nan     0.0100    0.0002
##     80        0.0151             nan     0.0100    0.0000
##    100        0.0115             nan     0.0100    0.0000
##    120        0.0091             nan     0.0100    0.0000
##    140        0.0071             nan     0.0100    0.0001
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0045             nan     0.0100    0.0000
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0001
##      3        0.0420             nan     0.0100    0.0006
##      4        0.0413             nan     0.0100    0.0002
##      5        0.0407             nan     0.0100    0.0004
##      6        0.0401             nan     0.0100    0.0004
##      7        0.0395             nan     0.0100    0.0006
##      8        0.0393             nan     0.0100    0.0001
##      9        0.0386             nan     0.0100    0.0006
##     10        0.0382             nan     0.0100    0.0003
##     20        0.0332             nan     0.0100    0.0005
##     40        0.0257             nan     0.0100    0.0004
##     60        0.0203             nan     0.0100    0.0003
##     80        0.0158             nan     0.0100   -0.0000
##    100        0.0125             nan     0.0100    0.0001
##    120        0.0102             nan     0.0100    0.0001
##    140        0.0083             nan     0.0100    0.0001
##    160        0.0068             nan     0.0100    0.0000
##    180        0.0056             nan     0.0100    0.0000
##    200        0.0046             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0002
##      2        0.0432             nan     0.0100    0.0001
##      3        0.0426             nan     0.0100    0.0003
##      4        0.0422             nan     0.0100    0.0003
##      5        0.0416             nan     0.0100    0.0006
##      6        0.0410             nan     0.0100    0.0004
##      7        0.0405             nan     0.0100    0.0005
##      8        0.0401             nan     0.0100    0.0002
##      9        0.0396             nan     0.0100    0.0006
##     10        0.0391             nan     0.0100    0.0003
##     20        0.0349             nan     0.0100    0.0004
##     40        0.0279             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0001
##     80        0.0185             nan     0.0100    0.0001
##    100        0.0155             nan     0.0100    0.0000
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0111             nan     0.0100    0.0001
##    160        0.0097             nan     0.0100    0.0001
##    180        0.0086             nan     0.0100    0.0001
##    200        0.0076             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0007
##      2        0.0426             nan     0.0100    0.0003
##      3        0.0422             nan     0.0100    0.0001
##      4        0.0418             nan     0.0100    0.0001
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0408             nan     0.0100    0.0003
##      7        0.0400             nan     0.0100    0.0005
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0391             nan     0.0100    0.0005
##     10        0.0385             nan     0.0100    0.0003
##     20        0.0327             nan     0.0100    0.0004
##     40        0.0248             nan     0.0100    0.0001
##     60        0.0192             nan     0.0100    0.0003
##     80        0.0147             nan     0.0100    0.0001
##    100        0.0114             nan     0.0100    0.0000
##    120        0.0090             nan     0.0100    0.0001
##    140        0.0067             nan     0.0100    0.0000
##    160        0.0053             nan     0.0100    0.0001
##    180        0.0043             nan     0.0100   -0.0000
##    200        0.0034             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0005
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0420             nan     0.0100    0.0005
##      4        0.0413             nan     0.0100    0.0005
##      5        0.0407             nan     0.0100    0.0002
##      6        0.0401             nan     0.0100    0.0003
##      7        0.0397             nan     0.0100    0.0001
##      8        0.0390             nan     0.0100    0.0004
##      9        0.0382             nan     0.0100    0.0004
##     10        0.0377             nan     0.0100    0.0004
##     20        0.0330             nan     0.0100    0.0003
##     40        0.0251             nan     0.0100    0.0003
##     60        0.0194             nan     0.0100    0.0003
##     80        0.0154             nan     0.0100   -0.0000
##    100        0.0120             nan     0.0100   -0.0000
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0078             nan     0.0100    0.0001
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0004
##      2        0.0428             nan     0.0100    0.0005
##      3        0.0422             nan     0.0100    0.0005
##      4        0.0420             nan     0.0100   -0.0000
##      5        0.0415             nan     0.0100    0.0005
##      6        0.0411             nan     0.0100    0.0004
##      7        0.0406             nan     0.0100    0.0005
##      8        0.0403             nan     0.0100    0.0000
##      9        0.0398             nan     0.0100    0.0006
##     10        0.0392             nan     0.0100    0.0005
##     20        0.0350             nan     0.0100    0.0005
##     40        0.0280             nan     0.0100    0.0003
##     60        0.0228             nan     0.0100    0.0000
##     80        0.0194             nan     0.0100    0.0001
##    100        0.0164             nan     0.0100    0.0001
##    120        0.0142             nan     0.0100    0.0000
##    140        0.0122             nan     0.0100    0.0000
##    160        0.0106             nan     0.0100    0.0001
##    180        0.0093             nan     0.0100    0.0001
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0030
##      2        0.0385             nan     0.0500    0.0008
##      3        0.0373             nan     0.0500    0.0004
##      4        0.0351             nan     0.0500    0.0024
##      5        0.0343             nan     0.0500   -0.0004
##      6        0.0326             nan     0.0500    0.0020
##      7        0.0306             nan     0.0500    0.0013
##      8        0.0278             nan     0.0500    0.0022
##      9        0.0258             nan     0.0500    0.0011
##     10        0.0252             nan     0.0500    0.0002
##     20        0.0144             nan     0.0500    0.0001
##     40        0.0064             nan     0.0500    0.0003
##     60        0.0027             nan     0.0500    0.0000
##     80        0.0015             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0019
##      2        0.0386             nan     0.0500    0.0030
##      3        0.0359             nan     0.0500    0.0025
##      4        0.0341             nan     0.0500    0.0006
##      5        0.0315             nan     0.0500    0.0013
##      6        0.0295             nan     0.0500    0.0018
##      7        0.0278             nan     0.0500    0.0015
##      8        0.0263             nan     0.0500    0.0011
##      9        0.0248             nan     0.0500    0.0016
##     10        0.0235             nan     0.0500    0.0012
##     20        0.0143             nan     0.0500    0.0002
##     40        0.0058             nan     0.0500    0.0002
##     60        0.0029             nan     0.0500   -0.0000
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0030
##      2        0.0376             nan     0.0500    0.0028
##      3        0.0354             nan     0.0500    0.0022
##      4        0.0330             nan     0.0500    0.0020
##      5        0.0310             nan     0.0500    0.0021
##      6        0.0297             nan     0.0500    0.0015
##      7        0.0281             nan     0.0500    0.0015
##      8        0.0270             nan     0.0500   -0.0002
##      9        0.0256             nan     0.0500    0.0015
##     10        0.0246             nan     0.0500    0.0007
##     20        0.0168             nan     0.0500    0.0003
##     40        0.0092             nan     0.0500   -0.0000
##     60        0.0055             nan     0.0500   -0.0001
##     80        0.0038             nan     0.0500   -0.0000
##    100        0.0024             nan     0.0500   -0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500    0.0000
##    180        0.0008             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0500    0.0033
##      2        0.0368             nan     0.0500    0.0020
##      3        0.0344             nan     0.0500    0.0015
##      4        0.0319             nan     0.0500    0.0024
##      5        0.0307             nan     0.0500    0.0002
##      6        0.0287             nan     0.0500    0.0019
##      7        0.0267             nan     0.0500    0.0015
##      8        0.0247             nan     0.0500    0.0013
##      9        0.0231             nan     0.0500    0.0014
##     10        0.0218             nan     0.0500    0.0009
##     20        0.0120             nan     0.0500    0.0000
##     40        0.0047             nan     0.0500   -0.0001
##     60        0.0019             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0500    0.0036
##      2        0.0373             nan     0.0500    0.0021
##      3        0.0355             nan     0.0500    0.0020
##      4        0.0331             nan     0.0500    0.0018
##      5        0.0310             nan     0.0500    0.0023
##      6        0.0288             nan     0.0500    0.0018
##      7        0.0268             nan     0.0500    0.0018
##      8        0.0249             nan     0.0500    0.0006
##      9        0.0231             nan     0.0500    0.0013
##     10        0.0226             nan     0.0500   -0.0002
##     20        0.0118             nan     0.0500    0.0000
##     40        0.0039             nan     0.0500    0.0002
##     60        0.0016             nan     0.0500   -0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0031
##      2        0.0392             nan     0.0500    0.0007
##      3        0.0379             nan     0.0500    0.0008
##      4        0.0347             nan     0.0500    0.0025
##      5        0.0332             nan     0.0500    0.0012
##      6        0.0315             nan     0.0500    0.0002
##      7        0.0293             nan     0.0500    0.0012
##      8        0.0284             nan     0.0500    0.0006
##      9        0.0266             nan     0.0500    0.0017
##     10        0.0255             nan     0.0500    0.0001
##     20        0.0167             nan     0.0500    0.0007
##     40        0.0087             nan     0.0500    0.0001
##     60        0.0055             nan     0.0500    0.0001
##     80        0.0037             nan     0.0500   -0.0000
##    100        0.0027             nan     0.0500   -0.0000
##    120        0.0023             nan     0.0500   -0.0000
##    140        0.0016             nan     0.0500   -0.0000
##    160        0.0013             nan     0.0500   -0.0000
##    180        0.0010             nan     0.0500   -0.0000
##    200        0.0009             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0034
##      2        0.0375             nan     0.0500    0.0023
##      3        0.0348             nan     0.0500    0.0024
##      4        0.0333             nan     0.0500    0.0012
##      5        0.0310             nan     0.0500    0.0015
##      6        0.0293             nan     0.0500    0.0006
##      7        0.0268             nan     0.0500    0.0012
##      8        0.0246             nan     0.0500    0.0017
##      9        0.0227             nan     0.0500    0.0009
##     10        0.0211             nan     0.0500    0.0008
##     20        0.0113             nan     0.0500    0.0006
##     40        0.0035             nan     0.0500    0.0000
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.0500    0.0034
##      2        0.0380             nan     0.0500    0.0006
##      3        0.0347             nan     0.0500    0.0018
##      4        0.0341             nan     0.0500   -0.0002
##      5        0.0319             nan     0.0500    0.0019
##      6        0.0294             nan     0.0500    0.0007
##      7        0.0269             nan     0.0500    0.0022
##      8        0.0253             nan     0.0500    0.0010
##      9        0.0241             nan     0.0500    0.0008
##     10        0.0227             nan     0.0500    0.0008
##     20        0.0114             nan     0.0500    0.0005
##     40        0.0039             nan     0.0500    0.0001
##     60        0.0014             nan     0.0500    0.0000
##     80        0.0009             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0017
##      2        0.0381             nan     0.0500    0.0024
##      3        0.0355             nan     0.0500    0.0025
##      4        0.0332             nan     0.0500    0.0022
##      5        0.0323             nan     0.0500    0.0001
##      6        0.0303             nan     0.0500    0.0003
##      7        0.0283             nan     0.0500    0.0019
##      8        0.0268             nan     0.0500    0.0011
##      9        0.0254             nan     0.0500    0.0015
##     10        0.0245             nan     0.0500    0.0005
##     20        0.0158             nan     0.0500    0.0001
##     40        0.0083             nan     0.0500    0.0002
##     60        0.0052             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500   -0.0001
##    100        0.0025             nan     0.0500   -0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.1000   -0.0021
##      2        0.0368             nan     0.1000    0.0050
##      3        0.0318             nan     0.1000    0.0037
##      4        0.0289             nan     0.1000    0.0024
##      5        0.0258             nan     0.1000    0.0012
##      6        0.0235             nan     0.1000    0.0030
##      7        0.0215             nan     0.1000   -0.0007
##      8        0.0188             nan     0.1000    0.0012
##      9        0.0164             nan     0.1000    0.0016
##     10        0.0147             nan     0.1000    0.0011
##     20        0.0068             nan     0.1000    0.0003
##     40        0.0020             nan     0.1000   -0.0000
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.1000    0.0001
##      2        0.0365             nan     0.1000    0.0035
##      3        0.0314             nan     0.1000    0.0039
##      4        0.0276             nan     0.1000    0.0039
##      5        0.0246             nan     0.1000    0.0028
##      6        0.0216             nan     0.1000    0.0028
##      7        0.0199             nan     0.1000    0.0012
##      8        0.0177             nan     0.1000    0.0019
##      9        0.0154             nan     0.1000    0.0014
##     10        0.0135             nan     0.1000    0.0016
##     20        0.0052             nan     0.1000   -0.0001
##     40        0.0012             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.1000    0.0035
##      2        0.0364             nan     0.1000    0.0007
##      3        0.0312             nan     0.1000    0.0043
##      4        0.0285             nan     0.1000    0.0026
##      5        0.0249             nan     0.1000    0.0020
##      6        0.0234             nan     0.1000    0.0005
##      7        0.0223             nan     0.1000   -0.0010
##      8        0.0203             nan     0.1000    0.0023
##      9        0.0187             nan     0.1000    0.0008
##     10        0.0174             nan     0.1000    0.0005
##     20        0.0074             nan     0.1000    0.0006
##     40        0.0033             nan     0.1000    0.0001
##     60        0.0021             nan     0.1000    0.0001
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0376             nan     0.1000    0.0039
##      2        0.0326             nan     0.1000    0.0030
##      3        0.0301             nan     0.1000    0.0005
##      4        0.0282             nan     0.1000   -0.0007
##      5        0.0248             nan     0.1000    0.0034
##      6        0.0217             nan     0.1000    0.0026
##      7        0.0185             nan     0.1000    0.0021
##      8        0.0158             nan     0.1000    0.0026
##      9        0.0144             nan     0.1000    0.0014
##     10        0.0120             nan     0.1000    0.0016
##     20        0.0038             nan     0.1000    0.0002
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0033
##      2        0.0319             nan     0.1000    0.0053
##      3        0.0272             nan     0.1000    0.0033
##      4        0.0258             nan     0.1000    0.0001
##      5        0.0227             nan     0.1000    0.0034
##      6        0.0197             nan     0.1000    0.0004
##      7        0.0175             nan     0.1000    0.0021
##      8        0.0156             nan     0.1000    0.0015
##      9        0.0136             nan     0.1000    0.0007
##     10        0.0118             nan     0.1000    0.0015
##     20        0.0036             nan     0.1000    0.0000
##     40        0.0008             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.1000    0.0055
##      2        0.0332             nan     0.1000    0.0034
##      3        0.0300             nan     0.1000    0.0033
##      4        0.0274             nan     0.1000    0.0021
##      5        0.0237             nan     0.1000    0.0022
##      6        0.0226             nan     0.1000    0.0003
##      7        0.0213             nan     0.1000    0.0008
##      8        0.0192             nan     0.1000    0.0019
##      9        0.0175             nan     0.1000    0.0014
##     10        0.0159             nan     0.1000    0.0016
##     20        0.0079             nan     0.1000    0.0004
##     40        0.0038             nan     0.1000   -0.0001
##     60        0.0020             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000   -0.0001
##    100        0.0008             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0016
##      2        0.0355             nan     0.1000   -0.0004
##      3        0.0299             nan     0.1000    0.0044
##      4        0.0256             nan     0.1000    0.0025
##      5        0.0215             nan     0.1000    0.0021
##      6        0.0190             nan     0.1000    0.0019
##      7        0.0160             nan     0.1000    0.0018
##      8        0.0139             nan     0.1000    0.0013
##      9        0.0115             nan     0.1000    0.0013
##     10        0.0104             nan     0.1000    0.0005
##     20        0.0029             nan     0.1000   -0.0001
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0386             nan     0.1000    0.0054
##      2        0.0345             nan     0.1000   -0.0004
##      3        0.0294             nan     0.1000    0.0026
##      4        0.0254             nan     0.1000    0.0029
##      5        0.0222             nan     0.1000    0.0029
##      6        0.0190             nan     0.1000    0.0016
##      7        0.0174             nan     0.1000    0.0013
##      8        0.0150             nan     0.1000    0.0005
##      9        0.0126             nan     0.1000    0.0016
##     10        0.0112             nan     0.1000    0.0006
##     20        0.0041             nan     0.1000    0.0003
##     40        0.0010             nan     0.1000    0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.1000    0.0031
##      2        0.0347             nan     0.1000    0.0051
##      3        0.0318             nan     0.1000    0.0034
##      4        0.0283             nan     0.1000    0.0035
##      5        0.0261             nan     0.1000    0.0018
##      6        0.0237             nan     0.1000    0.0008
##      7        0.0212             nan     0.1000    0.0020
##      8        0.0194             nan     0.1000    0.0016
##      9        0.0175             nan     0.1000    0.0002
##     10        0.0172             nan     0.1000   -0.0015
##     20        0.0102             nan     0.1000    0.0003
##     40        0.0041             nan     0.1000    0.0002
##     60        0.0026             nan     0.1000   -0.0001
##     80        0.0012             nan     0.1000   -0.0001
##    100        0.0008             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000    0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0100    0.0005
##      2        0.0407             nan     0.0100    0.0006
##      3        0.0403             nan     0.0100    0.0002
##      4        0.0398             nan     0.0100    0.0005
##      5        0.0393             nan     0.0100    0.0005
##      6        0.0388             nan     0.0100    0.0004
##      7        0.0383             nan     0.0100    0.0004
##      8        0.0378             nan     0.0100    0.0004
##      9        0.0373             nan     0.0100    0.0005
##     10        0.0368             nan     0.0100    0.0005
##     20        0.0324             nan     0.0100    0.0004
##     40        0.0261             nan     0.0100    0.0002
##     60        0.0203             nan     0.0100    0.0003
##     80        0.0165             nan     0.0100    0.0001
##    100        0.0136             nan     0.0100    0.0001
##    120        0.0113             nan     0.0100    0.0001
##    140        0.0092             nan     0.0100   -0.0000
##    160        0.0079             nan     0.0100   -0.0000
##    180        0.0067             nan     0.0100    0.0001
##    200        0.0058             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0100    0.0006
##      2        0.0409             nan     0.0100    0.0004
##      3        0.0404             nan     0.0100    0.0005
##      4        0.0398             nan     0.0100    0.0004
##      5        0.0393             nan     0.0100    0.0003
##      6        0.0387             nan     0.0100    0.0004
##      7        0.0381             nan     0.0100    0.0005
##      8        0.0377             nan     0.0100    0.0005
##      9        0.0373             nan     0.0100    0.0002
##     10        0.0369             nan     0.0100    0.0004
##     20        0.0326             nan     0.0100    0.0000
##     40        0.0260             nan     0.0100   -0.0001
##     60        0.0213             nan     0.0100    0.0002
##     80        0.0177             nan     0.0100    0.0001
##    100        0.0145             nan     0.0100    0.0001
##    120        0.0122             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0089             nan     0.0100    0.0000
##    180        0.0075             nan     0.0100    0.0001
##    200        0.0065             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0100    0.0005
##      2        0.0409             nan     0.0100    0.0006
##      3        0.0405             nan     0.0100    0.0002
##      4        0.0400             nan     0.0100    0.0004
##      5        0.0396             nan     0.0100    0.0004
##      6        0.0392             nan     0.0100    0.0004
##      7        0.0389             nan     0.0100    0.0001
##      8        0.0385             nan     0.0100    0.0004
##      9        0.0379             nan     0.0100    0.0004
##     10        0.0375             nan     0.0100    0.0004
##     20        0.0337             nan     0.0100    0.0002
##     40        0.0274             nan     0.0100    0.0003
##     60        0.0226             nan     0.0100    0.0001
##     80        0.0189             nan     0.0100    0.0001
##    100        0.0158             nan     0.0100    0.0002
##    120        0.0136             nan     0.0100   -0.0001
##    140        0.0120             nan     0.0100    0.0001
##    160        0.0104             nan     0.0100   -0.0000
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0081             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0100    0.0003
##      2        0.0410             nan     0.0100    0.0005
##      3        0.0403             nan     0.0100    0.0004
##      4        0.0399             nan     0.0100    0.0001
##      5        0.0395             nan     0.0100    0.0003
##      6        0.0391             nan     0.0100    0.0000
##      7        0.0383             nan     0.0100    0.0007
##      8        0.0378             nan     0.0100    0.0005
##      9        0.0370             nan     0.0100    0.0007
##     10        0.0366             nan     0.0100    0.0005
##     20        0.0314             nan     0.0100    0.0003
##     40        0.0240             nan     0.0100    0.0003
##     60        0.0184             nan     0.0100    0.0001
##     80        0.0140             nan     0.0100    0.0001
##    100        0.0111             nan     0.0100    0.0002
##    120        0.0089             nan     0.0100    0.0001
##    140        0.0072             nan     0.0100    0.0000
##    160        0.0058             nan     0.0100    0.0000
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0100    0.0004
##      2        0.0409             nan     0.0100    0.0004
##      3        0.0403             nan     0.0100    0.0005
##      4        0.0398             nan     0.0100    0.0004
##      5        0.0391             nan     0.0100    0.0004
##      6        0.0384             nan     0.0100    0.0004
##      7        0.0378             nan     0.0100    0.0006
##      8        0.0373             nan     0.0100    0.0004
##      9        0.0366             nan     0.0100    0.0005
##     10        0.0361             nan     0.0100    0.0000
##     20        0.0316             nan     0.0100    0.0004
##     40        0.0254             nan     0.0100   -0.0000
##     60        0.0197             nan     0.0100    0.0002
##     80        0.0154             nan     0.0100    0.0001
##    100        0.0123             nan     0.0100    0.0001
##    120        0.0101             nan     0.0100    0.0000
##    140        0.0083             nan     0.0100    0.0001
##    160        0.0068             nan     0.0100    0.0001
##    180        0.0058             nan     0.0100    0.0000
##    200        0.0048             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0100    0.0005
##      2        0.0407             nan     0.0100    0.0005
##      3        0.0403             nan     0.0100    0.0003
##      4        0.0400             nan     0.0100    0.0003
##      5        0.0395             nan     0.0100    0.0003
##      6        0.0389             nan     0.0100    0.0004
##      7        0.0384             nan     0.0100    0.0005
##      8        0.0380             nan     0.0100    0.0002
##      9        0.0378             nan     0.0100    0.0001
##     10        0.0374             nan     0.0100    0.0002
##     20        0.0334             nan     0.0100    0.0001
##     40        0.0269             nan     0.0100    0.0003
##     60        0.0223             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0141             nan     0.0100    0.0001
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0106             nan     0.0100   -0.0001
##    180        0.0093             nan     0.0100    0.0001
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0100    0.0003
##      2        0.0410             nan     0.0100    0.0006
##      3        0.0404             nan     0.0100    0.0005
##      4        0.0398             nan     0.0100    0.0005
##      5        0.0391             nan     0.0100    0.0005
##      6        0.0384             nan     0.0100    0.0009
##      7        0.0380             nan     0.0100    0.0002
##      8        0.0374             nan     0.0100    0.0007
##      9        0.0367             nan     0.0100    0.0005
##     10        0.0361             nan     0.0100    0.0003
##     20        0.0309             nan     0.0100    0.0002
##     40        0.0225             nan     0.0100    0.0002
##     60        0.0171             nan     0.0100    0.0002
##     80        0.0131             nan     0.0100    0.0001
##    100        0.0103             nan     0.0100    0.0001
##    120        0.0083             nan     0.0100    0.0000
##    140        0.0066             nan     0.0100    0.0001
##    160        0.0052             nan     0.0100    0.0000
##    180        0.0043             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0100    0.0006
##      2        0.0408             nan     0.0100    0.0005
##      3        0.0401             nan     0.0100    0.0005
##      4        0.0396             nan     0.0100    0.0004
##      5        0.0389             nan     0.0100    0.0004
##      6        0.0383             nan     0.0100    0.0005
##      7        0.0376             nan     0.0100    0.0006
##      8        0.0372             nan     0.0100    0.0005
##      9        0.0368             nan     0.0100    0.0003
##     10        0.0362             nan     0.0100    0.0003
##     20        0.0312             nan     0.0100    0.0004
##     40        0.0236             nan     0.0100    0.0002
##     60        0.0179             nan     0.0100    0.0002
##     80        0.0139             nan     0.0100    0.0001
##    100        0.0112             nan     0.0100    0.0002
##    120        0.0092             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0000
##    160        0.0059             nan     0.0100   -0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0042             nan     0.0100   -0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0100    0.0003
##      2        0.0410             nan     0.0100    0.0005
##      3        0.0404             nan     0.0100    0.0006
##      4        0.0401             nan     0.0100    0.0004
##      5        0.0397             nan     0.0100    0.0001
##      6        0.0393             nan     0.0100    0.0002
##      7        0.0389             nan     0.0100    0.0003
##      8        0.0385             nan     0.0100    0.0003
##      9        0.0380             nan     0.0100    0.0002
##     10        0.0375             nan     0.0100    0.0004
##     20        0.0335             nan     0.0100    0.0002
##     40        0.0275             nan     0.0100    0.0002
##     60        0.0223             nan     0.0100    0.0001
##     80        0.0189             nan     0.0100   -0.0001
##    100        0.0160             nan     0.0100    0.0001
##    120        0.0137             nan     0.0100    0.0000
##    140        0.0120             nan     0.0100   -0.0000
##    160        0.0105             nan     0.0100    0.0001
##    180        0.0094             nan     0.0100    0.0001
##    200        0.0085             nan     0.0100    0.0000
## 
## - Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.0500    0.0018
##      2        0.0379             nan     0.0500    0.0006
##      3        0.0353             nan     0.0500    0.0018
##      4        0.0335             nan     0.0500    0.0016
##      5        0.0312             nan     0.0500    0.0013
##      6        0.0303             nan     0.0500    0.0001
##      7        0.0298             nan     0.0500   -0.0001
##      8        0.0287             nan     0.0500    0.0004
##      9        0.0270             nan     0.0500    0.0016
##     10        0.0263             nan     0.0500   -0.0005
##     20        0.0147             nan     0.0500    0.0006
##     40        0.0068             nan     0.0500   -0.0000
##     60        0.0035             nan     0.0500    0.0001
##     80        0.0019             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500   -0.0001
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0010
##      2        0.0377             nan     0.0500    0.0027
##      3        0.0352             nan     0.0500    0.0011
##      4        0.0329             nan     0.0500    0.0014
##      5        0.0309             nan     0.0500    0.0017
##      6        0.0290             nan     0.0500    0.0013
##      7        0.0285             nan     0.0500   -0.0004
##      8        0.0269             nan     0.0500    0.0016
##      9        0.0258             nan     0.0500    0.0006
##     10        0.0246             nan     0.0500    0.0011
##     20        0.0155             nan     0.0500   -0.0007
##     40        0.0062             nan     0.0500    0.0001
##     60        0.0034             nan     0.0500   -0.0000
##     80        0.0021             nan     0.0500   -0.0000
##    100        0.0012             nan     0.0500   -0.0001
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0006             nan     0.0500   -0.0000
##    160        0.0004             nan     0.0500   -0.0000
##    180        0.0003             nan     0.0500   -0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.0500    0.0027
##      2        0.0374             nan     0.0500    0.0004
##      3        0.0360             nan     0.0500    0.0003
##      4        0.0336             nan     0.0500    0.0018
##      5        0.0322             nan     0.0500   -0.0002
##      6        0.0305             nan     0.0500    0.0018
##      7        0.0287             nan     0.0500    0.0009
##      8        0.0271             nan     0.0500    0.0017
##      9        0.0254             nan     0.0500    0.0013
##     10        0.0239             nan     0.0500    0.0011
##     20        0.0153             nan     0.0500    0.0001
##     40        0.0077             nan     0.0500    0.0002
##     60        0.0045             nan     0.0500   -0.0001
##     80        0.0031             nan     0.0500   -0.0000
##    100        0.0020             nan     0.0500   -0.0000
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0389             nan     0.0500    0.0016
##      2        0.0363             nan     0.0500    0.0023
##      3        0.0342             nan     0.0500    0.0022
##      4        0.0316             nan     0.0500    0.0021
##      5        0.0291             nan     0.0500    0.0016
##      6        0.0271             nan     0.0500    0.0015
##      7        0.0249             nan     0.0500    0.0016
##      8        0.0231             nan     0.0500    0.0013
##      9        0.0219             nan     0.0500    0.0006
##     10        0.0203             nan     0.0500    0.0009
##     20        0.0102             nan     0.0500    0.0005
##     40        0.0034             nan     0.0500    0.0000
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.0500    0.0021
##      2        0.0370             nan     0.0500    0.0030
##      3        0.0349             nan     0.0500    0.0014
##      4        0.0322             nan     0.0500    0.0010
##      5        0.0295             nan     0.0500    0.0025
##      6        0.0272             nan     0.0500    0.0020
##      7        0.0255             nan     0.0500    0.0013
##      8        0.0241             nan     0.0500    0.0014
##      9        0.0231             nan     0.0500    0.0014
##     10        0.0219             nan     0.0500    0.0008
##     20        0.0115             nan     0.0500    0.0003
##     40        0.0041             nan     0.0500    0.0000
##     60        0.0022             nan     0.0500   -0.0001
##     80        0.0012             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.0500    0.0028
##      2        0.0372             nan     0.0500    0.0019
##      3        0.0345             nan     0.0500    0.0022
##      4        0.0320             nan     0.0500    0.0012
##      5        0.0306             nan     0.0500    0.0014
##      6        0.0293             nan     0.0500    0.0007
##      7        0.0272             nan     0.0500    0.0012
##      8        0.0260             nan     0.0500    0.0006
##      9        0.0241             nan     0.0500    0.0012
##     10        0.0230             nan     0.0500    0.0011
##     20        0.0150             nan     0.0500    0.0001
##     40        0.0078             nan     0.0500    0.0001
##     60        0.0046             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500   -0.0000
##    100        0.0026             nan     0.0500    0.0000
##    120        0.0020             nan     0.0500   -0.0000
##    140        0.0015             nan     0.0500   -0.0000
##    160        0.0011             nan     0.0500    0.0000
##    180        0.0008             nan     0.0500    0.0000
##    200        0.0006             nan     0.0500    0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.0500    0.0026
##      2        0.0361             nan     0.0500   -0.0001
##      3        0.0340             nan     0.0500    0.0002
##      4        0.0319             nan     0.0500    0.0022
##      5        0.0293             nan     0.0500    0.0024
##      6        0.0271             nan     0.0500    0.0017
##      7        0.0249             nan     0.0500    0.0021
##      8        0.0229             nan     0.0500    0.0009
##      9        0.0215             nan     0.0500    0.0004
##     10        0.0203             nan     0.0500    0.0003
##     20        0.0101             nan     0.0500    0.0004
##     40        0.0028             nan     0.0500   -0.0000
##     60        0.0010             nan     0.0500   -0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.0500    0.0022
##      2        0.0364             nan     0.0500    0.0027
##      3        0.0337             nan     0.0500    0.0016
##      4        0.0314             nan     0.0500    0.0016
##      5        0.0299             nan     0.0500    0.0009
##      6        0.0283             nan     0.0500    0.0018
##      7        0.0258             nan     0.0500    0.0016
##      8        0.0242             nan     0.0500    0.0007
##      9        0.0226             nan     0.0500    0.0014
##     10        0.0222             nan     0.0500   -0.0007
##     20        0.0107             nan     0.0500    0.0009
##     40        0.0032             nan     0.0500   -0.0000
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.0500    0.0023
##      2        0.0371             nan     0.0500    0.0026
##      3        0.0344             nan     0.0500    0.0019
##      4        0.0326             nan     0.0500    0.0016
##      5        0.0308             nan     0.0500    0.0020
##      6        0.0291             nan     0.0500    0.0017
##      7        0.0285             nan     0.0500   -0.0006
##      8        0.0273             nan     0.0500    0.0011
##      9        0.0259             nan     0.0500    0.0009
##     10        0.0250             nan     0.0500    0.0008
##     20        0.0161             nan     0.0500    0.0001
##     40        0.0088             nan     0.0500    0.0002
##     60        0.0058             nan     0.0500    0.0001
##     80        0.0038             nan     0.0500    0.0000
##    100        0.0026             nan     0.0500    0.0001
##    120        0.0020             nan     0.0500    0.0000
##    140        0.0015             nan     0.0500    0.0000
##    160        0.0012             nan     0.0500   -0.0000
##    180        0.0009             nan     0.0500    0.0000
##    200        0.0008             nan     0.0500   -0.0000
## 
## - Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.1000    0.0012
##      2        0.0349             nan     0.1000    0.0028
##      3        0.0307             nan     0.1000    0.0040
##      4        0.0271             nan     0.1000    0.0027
##      5        0.0239             nan     0.1000    0.0021
##      6        0.0214             nan     0.1000    0.0022
##      7        0.0190             nan     0.1000    0.0024
##      8        0.0182             nan     0.1000   -0.0005
##      9        0.0180             nan     0.1000   -0.0007
##     10        0.0176             nan     0.1000   -0.0017
##     20        0.0069             nan     0.1000    0.0003
##     40        0.0023             nan     0.1000    0.0001
##     60        0.0008             nan     0.1000    0.0000
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0039
##      2        0.0335             nan     0.1000    0.0005
##      3        0.0303             nan     0.1000    0.0016
##      4        0.0266             nan     0.1000    0.0003
##      5        0.0243             nan     0.1000   -0.0002
##      6        0.0211             nan     0.1000    0.0010
##      7        0.0201             nan     0.1000    0.0006
##      8        0.0197             nan     0.1000   -0.0013
##      9        0.0176             nan     0.1000    0.0018
##     10        0.0154             nan     0.1000    0.0007
##     20        0.0083             nan     0.1000   -0.0007
##     40        0.0034             nan     0.1000   -0.0002
##     60        0.0012             nan     0.1000    0.0000
##     80        0.0006             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.1000    0.0028
##      2        0.0316             nan     0.1000    0.0046
##      3        0.0282             nan     0.1000    0.0032
##      4        0.0247             nan     0.1000    0.0029
##      5        0.0231             nan     0.1000    0.0003
##      6        0.0203             nan     0.1000    0.0023
##      7        0.0183             nan     0.1000    0.0016
##      8        0.0164             nan     0.1000    0.0017
##      9        0.0155             nan     0.1000    0.0003
##     10        0.0150             nan     0.1000   -0.0003
##     20        0.0081             nan     0.1000    0.0004
##     40        0.0034             nan     0.1000   -0.0002
##     60        0.0019             nan     0.1000   -0.0001
##     80        0.0009             nan     0.1000   -0.0001
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0353             nan     0.1000    0.0050
##      2        0.0305             nan     0.1000    0.0040
##      3        0.0267             nan     0.1000    0.0034
##      4        0.0247             nan     0.1000   -0.0011
##      5        0.0209             nan     0.1000    0.0032
##      6        0.0180             nan     0.1000    0.0023
##      7        0.0158             nan     0.1000    0.0016
##      8        0.0143             nan     0.1000    0.0009
##      9        0.0124             nan     0.1000    0.0007
##     10        0.0119             nan     0.1000    0.0004
##     20        0.0052             nan     0.1000   -0.0000
##     40        0.0009             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0352             nan     0.1000    0.0060
##      2        0.0307             nan     0.1000    0.0047
##      3        0.0267             nan     0.1000    0.0034
##      4        0.0226             nan     0.1000    0.0033
##      5        0.0190             nan     0.1000    0.0026
##      6        0.0157             nan     0.1000    0.0011
##      7        0.0138             nan     0.1000    0.0016
##      8        0.0126             nan     0.1000    0.0007
##      9        0.0117             nan     0.1000    0.0004
##     10        0.0102             nan     0.1000    0.0001
##     20        0.0036             nan     0.1000   -0.0000
##     40        0.0012             nan     0.1000   -0.0000
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0028
##      2        0.0335             nan     0.1000    0.0045
##      3        0.0299             nan     0.1000    0.0042
##      4        0.0260             nan     0.1000    0.0016
##      5        0.0235             nan     0.1000    0.0022
##      6        0.0202             nan     0.1000    0.0019
##      7        0.0185             nan     0.1000    0.0015
##      8        0.0172             nan     0.1000   -0.0009
##      9        0.0158             nan     0.1000    0.0007
##     10        0.0153             nan     0.1000   -0.0002
##     20        0.0089             nan     0.1000    0.0003
##     40        0.0037             nan     0.1000    0.0000
##     60        0.0020             nan     0.1000    0.0001
##     80        0.0013             nan     0.1000    0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000    0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0350             nan     0.1000    0.0052
##      2        0.0298             nan     0.1000    0.0043
##      3        0.0243             nan     0.1000    0.0053
##      4        0.0216             nan     0.1000    0.0012
##      5        0.0194             nan     0.1000    0.0018
##      6        0.0162             nan     0.1000    0.0008
##      7        0.0131             nan     0.1000    0.0024
##      8        0.0120             nan     0.1000    0.0006
##      9        0.0105             nan     0.1000    0.0008
##     10        0.0096             nan     0.1000    0.0009
##     20        0.0040             nan     0.1000    0.0003
##     40        0.0007             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0355             nan     0.1000    0.0036
##      2        0.0314             nan     0.1000    0.0032
##      3        0.0274             nan     0.1000    0.0027
##      4        0.0238             nan     0.1000    0.0036
##      5        0.0226             nan     0.1000    0.0003
##      6        0.0214             nan     0.1000   -0.0010
##      7        0.0181             nan     0.1000    0.0027
##      8        0.0161             nan     0.1000    0.0016
##      9        0.0142             nan     0.1000    0.0017
##     10        0.0130             nan     0.1000    0.0006
##     20        0.0037             nan     0.1000    0.0002
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0371             nan     0.1000    0.0048
##      2        0.0326             nan     0.1000    0.0047
##      3        0.0291             nan     0.1000    0.0041
##      4        0.0273             nan     0.1000    0.0001
##      5        0.0245             nan     0.1000    0.0022
##      6        0.0229             nan     0.1000    0.0003
##      7        0.0205             nan     0.1000    0.0017
##      8        0.0195             nan     0.1000    0.0004
##      9        0.0180             nan     0.1000    0.0012
##     10        0.0166             nan     0.1000    0.0004
##     20        0.0090             nan     0.1000    0.0007
##     40        0.0039             nan     0.1000    0.0000
##     60        0.0016             nan     0.1000    0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0100    0.0005
##      2        0.0408             nan     0.0100    0.0004
##      3        0.0402             nan     0.0100    0.0006
##      4        0.0399             nan     0.0100    0.0004
##      5        0.0392             nan     0.0100    0.0005
##      6        0.0387             nan     0.0100    0.0005
##      7        0.0383             nan     0.0100    0.0005
##      8        0.0379             nan     0.0100    0.0005
##      9        0.0374             nan     0.0100    0.0003
##     10        0.0369             nan     0.0100    0.0005
##     20        0.0330             nan     0.0100    0.0004
##     40        0.0273             nan     0.0100    0.0000
##     60        0.0219             nan     0.0100    0.0003
##     80        0.0179             nan     0.0100    0.0002
##    100        0.0149             nan     0.0100   -0.0000
##    120        0.0124             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0085             nan     0.0100   -0.0000
##    180        0.0074             nan     0.0100    0.0000
##    200        0.0063             nan     0.0100    0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0006
##      2        0.0407             nan     0.0100    0.0002
##      3        0.0400             nan     0.0100    0.0006
##      4        0.0394             nan     0.0100    0.0005
##      5        0.0388             nan     0.0100    0.0005
##      6        0.0386             nan     0.0100   -0.0001
##      7        0.0382             nan     0.0100    0.0003
##      8        0.0377             nan     0.0100    0.0005
##      9        0.0372             nan     0.0100    0.0005
##     10        0.0366             nan     0.0100    0.0004
##     20        0.0325             nan     0.0100    0.0004
##     40        0.0258             nan     0.0100    0.0002
##     60        0.0211             nan     0.0100    0.0002
##     80        0.0177             nan     0.0100    0.0001
##    100        0.0144             nan     0.0100    0.0000
##    120        0.0118             nan     0.0100    0.0001
##    140        0.0099             nan     0.0100    0.0000
##    160        0.0084             nan     0.0100    0.0000
##    180        0.0072             nan     0.0100    0.0001
##    200        0.0062             nan     0.0100   -0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0006
##      2        0.0407             nan     0.0100    0.0003
##      3        0.0401             nan     0.0100    0.0005
##      4        0.0397             nan     0.0100    0.0005
##      5        0.0391             nan     0.0100    0.0004
##      6        0.0386             nan     0.0100    0.0005
##      7        0.0382             nan     0.0100    0.0004
##      8        0.0377             nan     0.0100    0.0004
##      9        0.0373             nan     0.0100    0.0004
##     10        0.0371             nan     0.0100   -0.0002
##     20        0.0338             nan     0.0100    0.0004
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0225             nan     0.0100    0.0001
##     80        0.0187             nan     0.0100    0.0000
##    100        0.0158             nan     0.0100    0.0000
##    120        0.0135             nan     0.0100    0.0001
##    140        0.0116             nan     0.0100    0.0000
##    160        0.0103             nan     0.0100    0.0001
##    180        0.0092             nan     0.0100   -0.0000
##    200        0.0083             nan     0.0100    0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0001
##      2        0.0406             nan     0.0100    0.0004
##      3        0.0400             nan     0.0100    0.0006
##      4        0.0396             nan     0.0100    0.0005
##      5        0.0390             nan     0.0100    0.0006
##      6        0.0384             nan     0.0100    0.0006
##      7        0.0379             nan     0.0100    0.0005
##      8        0.0375             nan     0.0100   -0.0000
##      9        0.0368             nan     0.0100    0.0002
##     10        0.0365             nan     0.0100    0.0001
##     20        0.0318             nan     0.0100    0.0005
##     40        0.0243             nan     0.0100   -0.0000
##     60        0.0184             nan     0.0100    0.0002
##     80        0.0142             nan     0.0100   -0.0000
##    100        0.0111             nan     0.0100    0.0001
##    120        0.0086             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0001
##    160        0.0057             nan     0.0100    0.0000
##    180        0.0046             nan     0.0100    0.0000
##    200        0.0036             nan     0.0100    0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0004
##      2        0.0403             nan     0.0100    0.0005
##      3        0.0398             nan     0.0100    0.0005
##      4        0.0393             nan     0.0100    0.0005
##      5        0.0387             nan     0.0100    0.0005
##      6        0.0384             nan     0.0100    0.0001
##      7        0.0378             nan     0.0100    0.0005
##      8        0.0372             nan     0.0100    0.0006
##      9        0.0367             nan     0.0100    0.0002
##     10        0.0364             nan     0.0100    0.0003
##     20        0.0320             nan     0.0100    0.0005
##     40        0.0244             nan     0.0100    0.0002
##     60        0.0191             nan     0.0100    0.0001
##     80        0.0150             nan     0.0100    0.0000
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0100             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0001
##    160        0.0065             nan     0.0100    0.0001
##    180        0.0053             nan     0.0100    0.0000
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0006
##      2        0.0405             nan     0.0100    0.0006
##      3        0.0400             nan     0.0100    0.0005
##      4        0.0393             nan     0.0100    0.0005
##      5        0.0389             nan     0.0100    0.0002
##      6        0.0384             nan     0.0100    0.0005
##      7        0.0381             nan     0.0100    0.0003
##      8        0.0376             nan     0.0100    0.0004
##      9        0.0370             nan     0.0100    0.0004
##     10        0.0367             nan     0.0100    0.0003
##     20        0.0323             nan     0.0100    0.0004
##     40        0.0257             nan     0.0100    0.0002
##     60        0.0210             nan     0.0100    0.0002
##     80        0.0179             nan     0.0100    0.0000
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0116             nan     0.0100    0.0001
##    160        0.0102             nan     0.0100    0.0001
##    180        0.0092             nan     0.0100   -0.0000
##    200        0.0084             nan     0.0100   -0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0002
##      2        0.0407             nan     0.0100    0.0003
##      3        0.0402             nan     0.0100   -0.0000
##      4        0.0398             nan     0.0100    0.0003
##      5        0.0392             nan     0.0100    0.0004
##      6        0.0385             nan     0.0100    0.0006
##      7        0.0378             nan     0.0100    0.0005
##      8        0.0373             nan     0.0100    0.0006
##      9        0.0366             nan     0.0100    0.0006
##     10        0.0359             nan     0.0100    0.0004
##     20        0.0309             nan     0.0100    0.0004
##     40        0.0228             nan     0.0100    0.0001
##     60        0.0175             nan     0.0100    0.0002
##     80        0.0132             nan     0.0100    0.0001
##    100        0.0099             nan     0.0100    0.0001
##    120        0.0077             nan     0.0100   -0.0000
##    140        0.0060             nan     0.0100    0.0001
##    160        0.0047             nan     0.0100    0.0000
##    180        0.0036             nan     0.0100   -0.0000
##    200        0.0029             nan     0.0100   -0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0410             nan     0.0100    0.0007
##      2        0.0404             nan     0.0100    0.0003
##      3        0.0398             nan     0.0100    0.0004
##      4        0.0392             nan     0.0100    0.0006
##      5        0.0387             nan     0.0100    0.0002
##      6        0.0383             nan     0.0100    0.0004
##      7        0.0378             nan     0.0100    0.0005
##      8        0.0372             nan     0.0100    0.0005
##      9        0.0367             nan     0.0100    0.0004
##     10        0.0362             nan     0.0100    0.0002
##     20        0.0312             nan     0.0100    0.0000
##     40        0.0238             nan     0.0100    0.0003
##     60        0.0181             nan     0.0100    0.0001
##     80        0.0141             nan     0.0100    0.0001
##    100        0.0110             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0001
##    160        0.0057             nan     0.0100    0.0001
##    180        0.0047             nan     0.0100    0.0000
##    200        0.0039             nan     0.0100   -0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0100    0.0003
##      2        0.0405             nan     0.0100    0.0006
##      3        0.0400             nan     0.0100    0.0005
##      4        0.0398             nan     0.0100    0.0000
##      5        0.0394             nan     0.0100    0.0004
##      6        0.0389             nan     0.0100    0.0005
##      7        0.0385             nan     0.0100    0.0002
##      8        0.0380             nan     0.0100    0.0005
##      9        0.0377             nan     0.0100    0.0002
##     10        0.0371             nan     0.0100    0.0005
##     20        0.0330             nan     0.0100    0.0003
##     40        0.0264             nan     0.0100    0.0001
##     60        0.0220             nan     0.0100    0.0002
##     80        0.0181             nan     0.0100    0.0001
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0132             nan     0.0100   -0.0000
##    140        0.0118             nan     0.0100   -0.0000
##    160        0.0103             nan     0.0100   -0.0000
##    180        0.0090             nan     0.0100    0.0001
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.0500    0.0020
##      2        0.0378             nan     0.0500   -0.0011
##      3        0.0366             nan     0.0500    0.0004
##      4        0.0340             nan     0.0500    0.0020
##      5        0.0322             nan     0.0500    0.0009
##      6        0.0300             nan     0.0500    0.0015
##      7        0.0279             nan     0.0500    0.0019
##      8        0.0260             nan     0.0500    0.0014
##      9        0.0243             nan     0.0500    0.0016
##     10        0.0235             nan     0.0500   -0.0001
##     20        0.0145             nan     0.0500    0.0005
##     40        0.0066             nan     0.0500    0.0002
##     60        0.0033             nan     0.0500    0.0002
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.0500    0.0016
##      2        0.0363             nan     0.0500    0.0017
##      3        0.0343             nan     0.0500    0.0018
##      4        0.0323             nan     0.0500    0.0020
##      5        0.0315             nan     0.0500   -0.0003
##      6        0.0308             nan     0.0500   -0.0007
##      7        0.0291             nan     0.0500    0.0008
##      8        0.0277             nan     0.0500    0.0008
##      9        0.0265             nan     0.0500    0.0001
##     10        0.0249             nan     0.0500    0.0015
##     20        0.0148             nan     0.0500    0.0005
##     40        0.0062             nan     0.0500    0.0000
##     60        0.0032             nan     0.0500    0.0001
##     80        0.0019             nan     0.0500    0.0000
##    100        0.0011             nan     0.0500    0.0000
##    120        0.0007             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.0500    0.0024
##      2        0.0363             nan     0.0500    0.0024
##      3        0.0344             nan     0.0500    0.0015
##      4        0.0325             nan     0.0500    0.0019
##      5        0.0317             nan     0.0500    0.0010
##      6        0.0297             nan     0.0500    0.0010
##      7        0.0283             nan     0.0500    0.0012
##      8        0.0261             nan     0.0500    0.0009
##      9        0.0247             nan     0.0500    0.0014
##     10        0.0234             nan     0.0500    0.0006
##     20        0.0149             nan     0.0500    0.0003
##     40        0.0082             nan     0.0500    0.0002
##     60        0.0054             nan     0.0500   -0.0000
##     80        0.0036             nan     0.0500   -0.0000
##    100        0.0022             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500   -0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.0500    0.0018
##      2        0.0369             nan     0.0500    0.0018
##      3        0.0348             nan     0.0500    0.0016
##      4        0.0333             nan     0.0500    0.0002
##      5        0.0311             nan     0.0500    0.0023
##      6        0.0285             nan     0.0500    0.0023
##      7        0.0273             nan     0.0500    0.0012
##      8        0.0255             nan     0.0500    0.0012
##      9        0.0243             nan     0.0500    0.0012
##     10        0.0223             nan     0.0500    0.0005
##     20        0.0113             nan     0.0500    0.0002
##     40        0.0040             nan     0.0500   -0.0001
##     60        0.0016             nan     0.0500    0.0000
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.0500    0.0016
##      2        0.0359             nan     0.0500    0.0012
##      3        0.0336             nan     0.0500    0.0017
##      4        0.0313             nan     0.0500    0.0015
##      5        0.0295             nan     0.0500    0.0018
##      6        0.0276             nan     0.0500    0.0017
##      7        0.0262             nan     0.0500    0.0008
##      8        0.0247             nan     0.0500    0.0009
##      9        0.0232             nan     0.0500    0.0015
##     10        0.0219             nan     0.0500    0.0011
##     20        0.0125             nan     0.0500    0.0007
##     40        0.0045             nan     0.0500    0.0003
##     60        0.0023             nan     0.0500   -0.0001
##     80        0.0012             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.0500    0.0029
##      2        0.0375             nan     0.0500    0.0013
##      3        0.0348             nan     0.0500    0.0015
##      4        0.0329             nan     0.0500    0.0021
##      5        0.0320             nan     0.0500    0.0006
##      6        0.0300             nan     0.0500    0.0021
##      7        0.0280             nan     0.0500    0.0017
##      8        0.0263             nan     0.0500    0.0014
##      9        0.0251             nan     0.0500    0.0014
##     10        0.0235             nan     0.0500    0.0014
##     20        0.0146             nan     0.0500    0.0001
##     40        0.0072             nan     0.0500    0.0002
##     60        0.0042             nan     0.0500    0.0000
##     80        0.0028             nan     0.0500    0.0001
##    100        0.0017             nan     0.0500   -0.0000
##    120        0.0013             nan     0.0500   -0.0000
##    140        0.0009             nan     0.0500    0.0000
##    160        0.0006             nan     0.0500    0.0000
##    180        0.0004             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.0500    0.0033
##      2        0.0355             nan     0.0500    0.0030
##      3        0.0334             nan     0.0500    0.0015
##      4        0.0303             nan     0.0500    0.0014
##      5        0.0281             nan     0.0500    0.0014
##      6        0.0264             nan     0.0500    0.0011
##      7        0.0245             nan     0.0500    0.0008
##      8        0.0239             nan     0.0500   -0.0004
##      9        0.0232             nan     0.0500   -0.0012
##     10        0.0215             nan     0.0500    0.0015
##     20        0.0114             nan     0.0500    0.0010
##     40        0.0038             nan     0.0500    0.0002
##     60        0.0011             nan     0.0500    0.0000
##     80        0.0004             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.0500    0.0008
##      2        0.0384             nan     0.0500    0.0010
##      3        0.0357             nan     0.0500    0.0020
##      4        0.0335             nan     0.0500    0.0023
##      5        0.0309             nan     0.0500    0.0024
##      6        0.0288             nan     0.0500    0.0021
##      7        0.0268             nan     0.0500    0.0018
##      8        0.0252             nan     0.0500    0.0003
##      9        0.0229             nan     0.0500    0.0013
##     10        0.0212             nan     0.0500    0.0017
##     20        0.0122             nan     0.0500    0.0007
##     40        0.0048             nan     0.0500   -0.0000
##     60        0.0020             nan     0.0500   -0.0000
##     80        0.0011             nan     0.0500    0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.0500    0.0026
##      2        0.0360             nan     0.0500    0.0025
##      3        0.0336             nan     0.0500    0.0024
##      4        0.0326             nan     0.0500   -0.0000
##      5        0.0307             nan     0.0500    0.0018
##      6        0.0300             nan     0.0500   -0.0004
##      7        0.0281             nan     0.0500    0.0001
##      8        0.0266             nan     0.0500    0.0007
##      9        0.0261             nan     0.0500   -0.0001
##     10        0.0251             nan     0.0500    0.0010
##     20        0.0154             nan     0.0500    0.0006
##     40        0.0085             nan     0.0500   -0.0002
##     60        0.0053             nan     0.0500    0.0000
##     80        0.0037             nan     0.0500    0.0000
##    100        0.0024             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0012             nan     0.0500    0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500    0.0000
## 
## - Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.1000    0.0049
##      2        0.0330             nan     0.1000    0.0043
##      3        0.0295             nan     0.1000    0.0015
##      4        0.0270             nan     0.1000    0.0021
##      5        0.0244             nan     0.1000    0.0026
##      6        0.0219             nan     0.1000    0.0020
##      7        0.0200             nan     0.1000    0.0013
##      8        0.0191             nan     0.1000    0.0003
##      9        0.0177             nan     0.1000    0.0013
##     10        0.0167             nan     0.1000    0.0006
##     20        0.0064             nan     0.1000    0.0001
##     40        0.0018             nan     0.1000   -0.0001
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0359             nan     0.1000    0.0051
##      2        0.0316             nan     0.1000    0.0041
##      3        0.0294             nan     0.1000   -0.0000
##      4        0.0256             nan     0.1000    0.0031
##      5        0.0223             nan     0.1000    0.0029
##      6        0.0197             nan     0.1000    0.0021
##      7        0.0178             nan     0.1000   -0.0001
##      8        0.0171             nan     0.1000    0.0001
##      9        0.0155             nan     0.1000    0.0015
##     10        0.0147             nan     0.1000   -0.0004
##     20        0.0061             nan     0.1000    0.0002
##     40        0.0016             nan     0.1000    0.0000
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0358             nan     0.1000    0.0033
##      2        0.0317             nan     0.1000    0.0043
##      3        0.0285             nan     0.1000    0.0012
##      4        0.0267             nan     0.1000    0.0014
##      5        0.0241             nan     0.1000    0.0005
##      6        0.0219             nan     0.1000    0.0021
##      7        0.0201             nan     0.1000    0.0018
##      8        0.0185             nan     0.1000    0.0008
##      9        0.0171             nan     0.1000    0.0007
##     10        0.0158             nan     0.1000    0.0013
##     20        0.0072             nan     0.1000    0.0001
##     40        0.0026             nan     0.1000    0.0000
##     60        0.0013             nan     0.1000    0.0000
##     80        0.0007             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0363             nan     0.1000    0.0033
##      2        0.0329             nan     0.1000    0.0028
##      3        0.0263             nan     0.1000    0.0069
##      4        0.0223             nan     0.1000    0.0018
##      5        0.0188             nan     0.1000    0.0023
##      6        0.0166             nan     0.1000    0.0018
##      7        0.0146             nan     0.1000    0.0011
##      8        0.0125             nan     0.1000    0.0021
##      9        0.0108             nan     0.1000    0.0013
##     10        0.0096             nan     0.1000    0.0008
##     20        0.0029             nan     0.1000    0.0003
##     40        0.0005             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0358             nan     0.1000    0.0052
##      2        0.0305             nan     0.1000    0.0048
##      3        0.0266             nan     0.1000    0.0022
##      4        0.0239             nan     0.1000    0.0017
##      5        0.0208             nan     0.1000    0.0030
##      6        0.0192             nan     0.1000   -0.0001
##      7        0.0167             nan     0.1000    0.0027
##      8        0.0159             nan     0.1000   -0.0001
##      9        0.0135             nan     0.1000    0.0005
##     10        0.0119             nan     0.1000    0.0007
##     20        0.0047             nan     0.1000    0.0000
##     40        0.0010             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0052
##      2        0.0323             nan     0.1000    0.0041
##      3        0.0295             nan     0.1000    0.0023
##      4        0.0266             nan     0.1000   -0.0003
##      5        0.0236             nan     0.1000    0.0025
##      6        0.0214             nan     0.1000    0.0013
##      7        0.0186             nan     0.1000    0.0011
##      8        0.0178             nan     0.1000    0.0005
##      9        0.0157             nan     0.1000    0.0013
##     10        0.0145             nan     0.1000    0.0002
##     20        0.0080             nan     0.1000   -0.0002
##     40        0.0029             nan     0.1000   -0.0000
##     60        0.0013             nan     0.1000   -0.0001
##     80        0.0006             nan     0.1000    0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0009
##      2        0.0340             nan     0.1000   -0.0003
##      3        0.0283             nan     0.1000    0.0046
##      4        0.0242             nan     0.1000    0.0033
##      5        0.0201             nan     0.1000    0.0022
##      6        0.0177             nan     0.1000    0.0028
##      7        0.0153             nan     0.1000    0.0014
##      8        0.0126             nan     0.1000    0.0026
##      9        0.0116             nan     0.1000    0.0001
##     10        0.0095             nan     0.1000    0.0013
##     20        0.0028             nan     0.1000   -0.0001
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0013
##      2        0.0318             nan     0.1000    0.0021
##      3        0.0274             nan     0.1000    0.0034
##      4        0.0247             nan     0.1000    0.0033
##      5        0.0222             nan     0.1000    0.0015
##      6        0.0189             nan     0.1000    0.0033
##      7        0.0158             nan     0.1000    0.0022
##      8        0.0140             nan     0.1000    0.0009
##      9        0.0115             nan     0.1000    0.0014
##     10        0.0105             nan     0.1000    0.0004
##     20        0.0039             nan     0.1000    0.0001
##     40        0.0012             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0354             nan     0.1000    0.0048
##      2        0.0316             nan     0.1000    0.0042
##      3        0.0272             nan     0.1000    0.0024
##      4        0.0245             nan     0.1000    0.0014
##      5        0.0226             nan     0.1000    0.0012
##      6        0.0222             nan     0.1000   -0.0011
##      7        0.0200             nan     0.1000    0.0018
##      8        0.0185             nan     0.1000    0.0014
##      9        0.0171             nan     0.1000    0.0009
##     10        0.0155             nan     0.1000    0.0018
##     20        0.0079             nan     0.1000    0.0001
##     40        0.0030             nan     0.1000    0.0002
##     60        0.0013             nan     0.1000   -0.0000
##     80        0.0006             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0006
##      2        0.0428             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0006
##      4        0.0416             nan     0.0100    0.0003
##      5        0.0411             nan     0.0100    0.0004
##      6        0.0405             nan     0.0100    0.0006
##      7        0.0399             nan     0.0100    0.0005
##      8        0.0393             nan     0.0100    0.0005
##      9        0.0387             nan     0.0100    0.0006
##     10        0.0381             nan     0.0100    0.0003
##     20        0.0339             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100   -0.0000
##     60        0.0219             nan     0.0100    0.0001
##     80        0.0178             nan     0.0100    0.0002
##    100        0.0146             nan     0.0100    0.0001
##    120        0.0122             nan     0.0100    0.0000
##    140        0.0101             nan     0.0100    0.0001
##    160        0.0087             nan     0.0100    0.0001
##    180        0.0071             nan     0.0100    0.0001
##    200        0.0060             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0004
##      2        0.0434             nan     0.0100   -0.0002
##      3        0.0429             nan     0.0100    0.0004
##      4        0.0424             nan     0.0100    0.0005
##      5        0.0420             nan     0.0100    0.0003
##      6        0.0415             nan     0.0100    0.0006
##      7        0.0410             nan     0.0100    0.0004
##      8        0.0407             nan     0.0100    0.0003
##      9        0.0403             nan     0.0100    0.0004
##     10        0.0398             nan     0.0100    0.0005
##     20        0.0352             nan     0.0100    0.0002
##     40        0.0279             nan     0.0100    0.0004
##     60        0.0229             nan     0.0100    0.0001
##     80        0.0187             nan     0.0100    0.0001
##    100        0.0154             nan     0.0100    0.0001
##    120        0.0127             nan     0.0100    0.0001
##    140        0.0105             nan     0.0100    0.0000
##    160        0.0088             nan     0.0100    0.0000
##    180        0.0075             nan     0.0100    0.0000
##    200        0.0063             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0000
##      2        0.0430             nan     0.0100    0.0004
##      3        0.0424             nan     0.0100    0.0006
##      4        0.0419             nan     0.0100    0.0005
##      5        0.0413             nan     0.0100    0.0003
##      6        0.0409             nan     0.0100    0.0002
##      7        0.0404             nan     0.0100    0.0005
##      8        0.0398             nan     0.0100    0.0005
##      9        0.0392             nan     0.0100    0.0004
##     10        0.0387             nan     0.0100    0.0004
##     20        0.0343             nan     0.0100    0.0004
##     40        0.0270             nan     0.0100    0.0003
##     60        0.0219             nan     0.0100    0.0001
##     80        0.0183             nan     0.0100    0.0002
##    100        0.0156             nan     0.0100    0.0000
##    120        0.0133             nan     0.0100    0.0001
##    140        0.0117             nan     0.0100    0.0000
##    160        0.0099             nan     0.0100    0.0001
##    180        0.0090             nan     0.0100    0.0001
##    200        0.0079             nan     0.0100   -0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0006
##      2        0.0429             nan     0.0100    0.0005
##      3        0.0423             nan     0.0100    0.0002
##      4        0.0419             nan     0.0100    0.0001
##      5        0.0413             nan     0.0100    0.0004
##      6        0.0408             nan     0.0100    0.0001
##      7        0.0402             nan     0.0100    0.0005
##      8        0.0394             nan     0.0100    0.0007
##      9        0.0387             nan     0.0100    0.0007
##     10        0.0381             nan     0.0100    0.0006
##     20        0.0333             nan     0.0100    0.0004
##     40        0.0250             nan     0.0100    0.0003
##     60        0.0192             nan     0.0100    0.0002
##     80        0.0151             nan     0.0100   -0.0000
##    100        0.0118             nan     0.0100    0.0000
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0075             nan     0.0100   -0.0001
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0048             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0001
##      2        0.0430             nan     0.0100    0.0006
##      3        0.0424             nan     0.0100    0.0004
##      4        0.0417             nan     0.0100    0.0006
##      5        0.0413             nan     0.0100    0.0003
##      6        0.0409             nan     0.0100    0.0005
##      7        0.0402             nan     0.0100    0.0007
##      8        0.0396             nan     0.0100    0.0006
##      9        0.0392             nan     0.0100    0.0001
##     10        0.0389             nan     0.0100    0.0003
##     20        0.0345             nan     0.0100    0.0004
##     40        0.0267             nan     0.0100    0.0003
##     60        0.0206             nan     0.0100    0.0003
##     80        0.0163             nan     0.0100    0.0002
##    100        0.0129             nan     0.0100   -0.0000
##    120        0.0105             nan     0.0100    0.0000
##    140        0.0083             nan     0.0100    0.0000
##    160        0.0069             nan     0.0100    0.0000
##    180        0.0055             nan     0.0100    0.0001
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0003
##      2        0.0435             nan     0.0100   -0.0002
##      3        0.0430             nan     0.0100    0.0006
##      4        0.0424             nan     0.0100    0.0006
##      5        0.0421             nan     0.0100   -0.0002
##      6        0.0415             nan     0.0100    0.0006
##      7        0.0411             nan     0.0100    0.0003
##      8        0.0407             nan     0.0100    0.0003
##      9        0.0405             nan     0.0100   -0.0000
##     10        0.0401             nan     0.0100    0.0003
##     20        0.0355             nan     0.0100    0.0003
##     40        0.0282             nan     0.0100    0.0003
##     60        0.0233             nan     0.0100    0.0002
##     80        0.0194             nan     0.0100    0.0000
##    100        0.0162             nan     0.0100    0.0000
##    120        0.0138             nan     0.0100    0.0000
##    140        0.0121             nan     0.0100    0.0000
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0081             nan     0.0100    0.0001
## 
## - Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0006
##      2        0.0425             nan     0.0100    0.0007
##      3        0.0419             nan     0.0100    0.0006
##      4        0.0413             nan     0.0100    0.0007
##      5        0.0406             nan     0.0100    0.0007
##      6        0.0400             nan     0.0100    0.0006
##      7        0.0397             nan     0.0100    0.0002
##      8        0.0390             nan     0.0100    0.0008
##      9        0.0386             nan     0.0100    0.0003
##     10        0.0380             nan     0.0100    0.0003
##     20        0.0333             nan     0.0100    0.0001
##     40        0.0250             nan     0.0100    0.0002
##     60        0.0187             nan     0.0100    0.0002
##     80        0.0143             nan     0.0100    0.0000
##    100        0.0111             nan     0.0100    0.0001
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100    0.0001
##    160        0.0054             nan     0.0100    0.0000
##    180        0.0044             nan     0.0100    0.0000
##    200        0.0034             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0003
##      2        0.0431             nan     0.0100    0.0005
##      3        0.0428             nan     0.0100    0.0001
##      4        0.0421             nan     0.0100    0.0004
##      5        0.0419             nan     0.0100   -0.0001
##      6        0.0412             nan     0.0100    0.0003
##      7        0.0406             nan     0.0100    0.0005
##      8        0.0402             nan     0.0100    0.0001
##      9        0.0396             nan     0.0100    0.0005
##     10        0.0390             nan     0.0100    0.0002
##     20        0.0340             nan     0.0100    0.0003
##     40        0.0254             nan     0.0100    0.0002
##     60        0.0199             nan     0.0100    0.0003
##     80        0.0154             nan     0.0100    0.0001
##    100        0.0118             nan     0.0100    0.0001
##    120        0.0098             nan     0.0100    0.0001
##    140        0.0078             nan     0.0100    0.0001
##    160        0.0064             nan     0.0100    0.0001
##    180        0.0051             nan     0.0100    0.0001
##    200        0.0042             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0005
##      2        0.0432             nan     0.0100    0.0002
##      3        0.0428             nan     0.0100    0.0003
##      4        0.0422             nan     0.0100    0.0004
##      5        0.0419             nan     0.0100    0.0000
##      6        0.0414             nan     0.0100    0.0003
##      7        0.0410             nan     0.0100    0.0003
##      8        0.0406             nan     0.0100    0.0003
##      9        0.0400             nan     0.0100    0.0006
##     10        0.0395             nan     0.0100    0.0006
##     20        0.0356             nan     0.0100    0.0003
##     40        0.0285             nan     0.0100    0.0001
##     60        0.0235             nan     0.0100    0.0003
##     80        0.0195             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0139             nan     0.0100    0.0001
##    140        0.0118             nan     0.0100   -0.0000
##    160        0.0102             nan     0.0100    0.0001
##    180        0.0090             nan     0.0100   -0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0011
##      2        0.0400             nan     0.0500    0.0006
##      3        0.0386             nan     0.0500    0.0000
##      4        0.0361             nan     0.0500    0.0017
##      5        0.0350             nan     0.0500    0.0000
##      6        0.0324             nan     0.0500    0.0018
##      7        0.0304             nan     0.0500    0.0022
##      8        0.0290             nan     0.0500    0.0001
##      9        0.0274             nan     0.0500    0.0010
##     10        0.0254             nan     0.0500    0.0017
##     20        0.0142             nan     0.0500    0.0006
##     40        0.0056             nan     0.0500    0.0002
##     60        0.0026             nan     0.0500    0.0000
##     80        0.0013             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0030
##      2        0.0390             nan     0.0500    0.0019
##      3        0.0361             nan     0.0500    0.0031
##      4        0.0335             nan     0.0500    0.0022
##      5        0.0316             nan     0.0500    0.0020
##      6        0.0303             nan     0.0500    0.0008
##      7        0.0286             nan     0.0500    0.0019
##      8        0.0277             nan     0.0500    0.0005
##      9        0.0261             nan     0.0500    0.0014
##     10        0.0252             nan     0.0500    0.0005
##     20        0.0143             nan     0.0500    0.0007
##     40        0.0059             nan     0.0500    0.0001
##     60        0.0028             nan     0.0500    0.0000
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0028
##      2        0.0384             nan     0.0500    0.0028
##      3        0.0358             nan     0.0500    0.0024
##      4        0.0350             nan     0.0500   -0.0006
##      5        0.0323             nan     0.0500    0.0021
##      6        0.0302             nan     0.0500    0.0019
##      7        0.0292             nan     0.0500    0.0011
##      8        0.0278             nan     0.0500    0.0016
##      9        0.0272             nan     0.0500    0.0006
##     10        0.0257             nan     0.0500    0.0006
##     20        0.0159             nan     0.0500    0.0003
##     40        0.0083             nan     0.0500    0.0001
##     60        0.0049             nan     0.0500   -0.0001
##     80        0.0035             nan     0.0500    0.0000
##    100        0.0025             nan     0.0500    0.0000
##    120        0.0020             nan     0.0500   -0.0000
##    140        0.0015             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0500    0.0032
##      2        0.0375             nan     0.0500    0.0018
##      3        0.0346             nan     0.0500    0.0016
##      4        0.0315             nan     0.0500    0.0032
##      5        0.0285             nan     0.0500    0.0014
##      6        0.0266             nan     0.0500    0.0011
##      7        0.0252             nan     0.0500    0.0002
##      8        0.0229             nan     0.0500    0.0016
##      9        0.0222             nan     0.0500   -0.0001
##     10        0.0218             nan     0.0500   -0.0003
##     20        0.0121             nan     0.0500    0.0006
##     40        0.0042             nan     0.0500    0.0001
##     60        0.0014             nan     0.0500    0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0417             nan     0.0500    0.0025
##      2        0.0394             nan     0.0500    0.0009
##      3        0.0359             nan     0.0500    0.0032
##      4        0.0332             nan     0.0500    0.0012
##      5        0.0307             nan     0.0500    0.0022
##      6        0.0282             nan     0.0500    0.0018
##      7        0.0263             nan     0.0500    0.0014
##      8        0.0244             nan     0.0500    0.0016
##      9        0.0227             nan     0.0500    0.0018
##     10        0.0208             nan     0.0500    0.0016
##     20        0.0114             nan     0.0500   -0.0001
##     40        0.0037             nan     0.0500    0.0001
##     60        0.0015             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0415             nan     0.0500    0.0026
##      2        0.0392             nan     0.0500   -0.0005
##      3        0.0363             nan     0.0500    0.0019
##      4        0.0341             nan     0.0500    0.0024
##      5        0.0328             nan     0.0500   -0.0001
##      6        0.0316             nan     0.0500    0.0009
##      7        0.0297             nan     0.0500    0.0018
##      8        0.0287             nan     0.0500    0.0005
##      9        0.0269             nan     0.0500    0.0018
##     10        0.0252             nan     0.0500    0.0007
##     20        0.0155             nan     0.0500   -0.0003
##     40        0.0075             nan     0.0500    0.0001
##     60        0.0039             nan     0.0500    0.0000
##     80        0.0026             nan     0.0500    0.0000
##    100        0.0020             nan     0.0500    0.0000
##    120        0.0013             nan     0.0500    0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0004             nan     0.0500    0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.0500    0.0020
##      2        0.0385             nan     0.0500    0.0020
##      3        0.0358             nan     0.0500    0.0022
##      4        0.0325             nan     0.0500    0.0027
##      5        0.0288             nan     0.0500    0.0042
##      6        0.0265             nan     0.0500    0.0017
##      7        0.0246             nan     0.0500    0.0016
##      8        0.0228             nan     0.0500    0.0014
##      9        0.0218             nan     0.0500    0.0007
##     10        0.0200             nan     0.0500    0.0011
##     20        0.0096             nan     0.0500    0.0001
##     40        0.0028             nan     0.0500    0.0001
##     60        0.0010             nan     0.0500    0.0000
##     80        0.0004             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0031
##      2        0.0381             nan     0.0500    0.0024
##      3        0.0355             nan     0.0500    0.0031
##      4        0.0338             nan     0.0500    0.0008
##      5        0.0314             nan     0.0500    0.0021
##      6        0.0295             nan     0.0500    0.0015
##      7        0.0280             nan     0.0500    0.0017
##      8        0.0260             nan     0.0500    0.0018
##      9        0.0240             nan     0.0500    0.0015
##     10        0.0221             nan     0.0500    0.0017
##     20        0.0119             nan     0.0500    0.0009
##     40        0.0036             nan     0.0500    0.0001
##     60        0.0015             nan     0.0500   -0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0026
##      2        0.0391             nan     0.0500    0.0025
##      3        0.0370             nan     0.0500    0.0013
##      4        0.0348             nan     0.0500    0.0019
##      5        0.0325             nan     0.0500    0.0020
##      6        0.0306             nan     0.0500    0.0014
##      7        0.0293             nan     0.0500    0.0004
##      8        0.0285             nan     0.0500    0.0002
##      9        0.0267             nan     0.0500    0.0017
##     10        0.0256             nan     0.0500    0.0006
##     20        0.0166             nan     0.0500    0.0004
##     40        0.0084             nan     0.0500    0.0001
##     60        0.0048             nan     0.0500    0.0001
##     80        0.0029             nan     0.0500    0.0000
##    100        0.0021             nan     0.0500    0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0011             nan     0.0500    0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500    0.0000
## 
## - Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.1000   -0.0003
##      2        0.0389             nan     0.1000    0.0021
##      3        0.0331             nan     0.1000    0.0063
##      4        0.0289             nan     0.1000    0.0042
##      5        0.0251             nan     0.1000    0.0010
##      6        0.0217             nan     0.1000    0.0018
##      7        0.0182             nan     0.1000    0.0040
##      8        0.0166             nan     0.1000    0.0007
##      9        0.0144             nan     0.1000    0.0014
##     10        0.0126             nan     0.1000    0.0015
##     20        0.0051             nan     0.1000    0.0002
##     40        0.0015             nan     0.1000   -0.0001
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.1000    0.0026
##      2        0.0341             nan     0.1000    0.0047
##      3        0.0290             nan     0.1000    0.0041
##      4        0.0256             nan     0.1000    0.0028
##      5        0.0230             nan     0.1000    0.0020
##      6        0.0212             nan     0.1000    0.0003
##      7        0.0206             nan     0.1000   -0.0003
##      8        0.0184             nan     0.1000    0.0002
##      9        0.0178             nan     0.1000   -0.0006
##     10        0.0170             nan     0.1000   -0.0000
##     20        0.0069             nan     0.1000    0.0001
##     40        0.0018             nan     0.1000   -0.0001
##     60        0.0007             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.1000    0.0034
##      2        0.0379             nan     0.1000    0.0005
##      3        0.0338             nan     0.1000    0.0035
##      4        0.0313             nan     0.1000    0.0011
##      5        0.0303             nan     0.1000   -0.0003
##      6        0.0288             nan     0.1000    0.0015
##      7        0.0273             nan     0.1000   -0.0009
##      8        0.0237             nan     0.1000    0.0019
##      9        0.0221             nan     0.1000    0.0012
##     10        0.0205             nan     0.1000    0.0010
##     20        0.0095             nan     0.1000    0.0005
##     40        0.0034             nan     0.1000   -0.0001
##     60        0.0017             nan     0.1000    0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.1000    0.0001
##      2        0.0360             nan     0.1000    0.0050
##      3        0.0296             nan     0.1000    0.0024
##      4        0.0263             nan     0.1000    0.0027
##      5        0.0235             nan     0.1000    0.0019
##      6        0.0196             nan     0.1000    0.0029
##      7        0.0174             nan     0.1000    0.0020
##      8        0.0160             nan     0.1000    0.0015
##      9        0.0139             nan     0.1000    0.0014
##     10        0.0123             nan     0.1000    0.0009
##     20        0.0040             nan     0.1000    0.0001
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0050
##      2        0.0316             nan     0.1000    0.0054
##      3        0.0267             nan     0.1000    0.0030
##      4        0.0223             nan     0.1000    0.0026
##      5        0.0187             nan     0.1000    0.0029
##      6        0.0169             nan     0.1000    0.0023
##      7        0.0139             nan     0.1000    0.0020
##      8        0.0123             nan     0.1000    0.0010
##      9        0.0109             nan     0.1000    0.0011
##     10        0.0097             nan     0.1000    0.0012
##     20        0.0029             nan     0.1000    0.0001
##     40        0.0007             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.1000    0.0056
##      2        0.0382             nan     0.1000   -0.0029
##      3        0.0343             nan     0.1000    0.0042
##      4        0.0307             nan     0.1000    0.0040
##      5        0.0264             nan     0.1000    0.0031
##      6        0.0234             nan     0.1000    0.0026
##      7        0.0206             nan     0.1000    0.0021
##      8        0.0186             nan     0.1000    0.0019
##      9        0.0167             nan     0.1000    0.0019
##     10        0.0151             nan     0.1000    0.0008
##     20        0.0075             nan     0.1000    0.0000
##     40        0.0030             nan     0.1000   -0.0000
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0007             nan     0.1000   -0.0001
##    100        0.0004             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0054
##      2        0.0321             nan     0.1000    0.0064
##      3        0.0300             nan     0.1000    0.0002
##      4        0.0256             nan     0.1000    0.0038
##      5        0.0220             nan     0.1000    0.0031
##      6        0.0193             nan     0.1000    0.0018
##      7        0.0169             nan     0.1000    0.0002
##      8        0.0153             nan     0.1000    0.0009
##      9        0.0128             nan     0.1000    0.0010
##     10        0.0110             nan     0.1000    0.0016
##     20        0.0026             nan     0.1000    0.0001
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0401             nan     0.1000    0.0028
##      2        0.0344             nan     0.1000    0.0038
##      3        0.0291             nan     0.1000    0.0045
##      4        0.0259             nan     0.1000    0.0026
##      5        0.0229             nan     0.1000    0.0028
##      6        0.0192             nan     0.1000    0.0021
##      7        0.0173             nan     0.1000    0.0001
##      8        0.0162             nan     0.1000   -0.0010
##      9        0.0141             nan     0.1000    0.0019
##     10        0.0128             nan     0.1000    0.0009
##     20        0.0042             nan     0.1000    0.0001
##     40        0.0008             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.1000    0.0049
##      2        0.0327             nan     0.1000    0.0040
##      3        0.0304             nan     0.1000    0.0017
##      4        0.0267             nan     0.1000    0.0036
##      5        0.0251             nan     0.1000    0.0010
##      6        0.0234             nan     0.1000    0.0017
##      7        0.0216             nan     0.1000    0.0014
##      8        0.0203             nan     0.1000    0.0015
##      9        0.0182             nan     0.1000    0.0018
##     10        0.0165             nan     0.1000    0.0013
##     20        0.0073             nan     0.1000   -0.0000
##     40        0.0031             nan     0.1000   -0.0001
##     60        0.0015             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100   -0.0001
##      2        0.0423             nan     0.0100    0.0006
##      3        0.0417             nan     0.0100    0.0003
##      4        0.0415             nan     0.0100   -0.0002
##      5        0.0411             nan     0.0100    0.0001
##      6        0.0406             nan     0.0100    0.0005
##      7        0.0401             nan     0.0100    0.0002
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0392             nan     0.0100    0.0002
##     10        0.0389             nan     0.0100    0.0003
##     20        0.0344             nan     0.0100    0.0005
##     40        0.0281             nan     0.0100    0.0002
##     60        0.0227             nan     0.0100    0.0001
##     80        0.0183             nan     0.0100    0.0002
##    100        0.0149             nan     0.0100    0.0001
##    120        0.0128             nan     0.0100    0.0001
##    140        0.0106             nan     0.0100    0.0000
##    160        0.0089             nan     0.0100    0.0000
##    180        0.0077             nan     0.0100    0.0001
##    200        0.0065             nan     0.0100   -0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0004
##      2        0.0423             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100    0.0005
##      4        0.0413             nan     0.0100    0.0003
##      5        0.0408             nan     0.0100    0.0003
##      6        0.0404             nan     0.0100    0.0004
##      7        0.0399             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0001
##      9        0.0392             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0004
##     40        0.0280             nan     0.0100    0.0004
##     60        0.0230             nan     0.0100    0.0002
##     80        0.0186             nan     0.0100    0.0002
##    100        0.0155             nan     0.0100    0.0001
##    120        0.0131             nan     0.0100    0.0001
##    140        0.0114             nan     0.0100    0.0000
##    160        0.0099             nan     0.0100    0.0000
##    180        0.0085             nan     0.0100    0.0001
##    200        0.0073             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0005
##      2        0.0424             nan     0.0100    0.0003
##      3        0.0420             nan     0.0100    0.0003
##      4        0.0415             nan     0.0100    0.0004
##      5        0.0410             nan     0.0100    0.0004
##      6        0.0403             nan     0.0100    0.0005
##      7        0.0398             nan     0.0100    0.0005
##      8        0.0394             nan     0.0100    0.0004
##      9        0.0389             nan     0.0100    0.0004
##     10        0.0383             nan     0.0100    0.0005
##     20        0.0340             nan     0.0100    0.0004
##     40        0.0274             nan     0.0100    0.0001
##     60        0.0229             nan     0.0100    0.0002
##     80        0.0192             nan     0.0100    0.0000
##    100        0.0163             nan     0.0100    0.0001
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0118             nan     0.0100    0.0001
##    160        0.0104             nan     0.0100    0.0000
##    180        0.0091             nan     0.0100    0.0000
##    200        0.0082             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0426             nan     0.0100    0.0007
##      2        0.0419             nan     0.0100    0.0006
##      3        0.0414             nan     0.0100    0.0002
##      4        0.0411             nan     0.0100    0.0002
##      5        0.0405             nan     0.0100    0.0000
##      6        0.0400             nan     0.0100    0.0005
##      7        0.0392             nan     0.0100    0.0006
##      8        0.0387             nan     0.0100    0.0006
##      9        0.0380             nan     0.0100    0.0006
##     10        0.0377             nan     0.0100   -0.0002
##     20        0.0329             nan     0.0100    0.0002
##     40        0.0258             nan     0.0100    0.0001
##     60        0.0203             nan     0.0100    0.0002
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0122             nan     0.0100    0.0001
##    120        0.0099             nan     0.0100   -0.0000
##    140        0.0078             nan     0.0100    0.0001
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0051             nan     0.0100    0.0000
##    200        0.0042             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0429             nan     0.0100    0.0001
##      2        0.0422             nan     0.0100    0.0005
##      3        0.0416             nan     0.0100    0.0007
##      4        0.0412             nan     0.0100    0.0000
##      5        0.0407             nan     0.0100    0.0003
##      6        0.0401             nan     0.0100    0.0004
##      7        0.0397             nan     0.0100    0.0003
##      8        0.0393             nan     0.0100    0.0004
##      9        0.0389             nan     0.0100    0.0004
##     10        0.0383             nan     0.0100    0.0003
##     20        0.0335             nan     0.0100    0.0002
##     40        0.0262             nan     0.0100    0.0004
##     60        0.0207             nan     0.0100    0.0001
##     80        0.0163             nan     0.0100    0.0001
##    100        0.0129             nan     0.0100    0.0001
##    120        0.0100             nan     0.0100    0.0000
##    140        0.0081             nan     0.0100    0.0000
##    160        0.0065             nan     0.0100   -0.0000
##    180        0.0054             nan     0.0100    0.0000
##    200        0.0045             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0004
##      2        0.0423             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100    0.0005
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0406             nan     0.0100    0.0002
##      6        0.0403             nan     0.0100    0.0002
##      7        0.0397             nan     0.0100    0.0005
##      8        0.0393             nan     0.0100    0.0003
##      9        0.0390             nan     0.0100   -0.0000
##     10        0.0387             nan     0.0100    0.0004
##     20        0.0347             nan     0.0100    0.0002
##     40        0.0276             nan     0.0100    0.0003
##     60        0.0229             nan     0.0100    0.0002
##     80        0.0187             nan     0.0100    0.0002
##    100        0.0160             nan     0.0100    0.0001
##    120        0.0138             nan     0.0100    0.0001
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0108             nan     0.0100    0.0000
##    180        0.0099             nan     0.0100   -0.0000
##    200        0.0090             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0427             nan     0.0100    0.0002
##      2        0.0423             nan     0.0100    0.0003
##      3        0.0417             nan     0.0100    0.0007
##      4        0.0410             nan     0.0100    0.0003
##      5        0.0406             nan     0.0100    0.0004
##      6        0.0400             nan     0.0100    0.0006
##      7        0.0394             nan     0.0100    0.0004
##      8        0.0389             nan     0.0100    0.0002
##      9        0.0385             nan     0.0100    0.0003
##     10        0.0378             nan     0.0100    0.0005
##     20        0.0327             nan     0.0100    0.0005
##     40        0.0249             nan     0.0100    0.0003
##     60        0.0190             nan     0.0100    0.0002
##     80        0.0149             nan     0.0100    0.0001
##    100        0.0116             nan     0.0100    0.0002
##    120        0.0088             nan     0.0100    0.0001
##    140        0.0070             nan     0.0100   -0.0000
##    160        0.0055             nan     0.0100    0.0000
##    180        0.0045             nan     0.0100    0.0000
##    200        0.0035             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0425             nan     0.0100    0.0004
##      2        0.0420             nan     0.0100    0.0004
##      3        0.0415             nan     0.0100    0.0004
##      4        0.0409             nan     0.0100    0.0004
##      5        0.0402             nan     0.0100    0.0005
##      6        0.0394             nan     0.0100    0.0007
##      7        0.0388             nan     0.0100    0.0003
##      8        0.0383             nan     0.0100    0.0004
##      9        0.0380             nan     0.0100    0.0003
##     10        0.0374             nan     0.0100    0.0006
##     20        0.0322             nan     0.0100    0.0004
##     40        0.0247             nan     0.0100    0.0002
##     60        0.0193             nan     0.0100    0.0001
##     80        0.0153             nan     0.0100    0.0001
##    100        0.0121             nan     0.0100    0.0000
##    120        0.0096             nan     0.0100    0.0001
##    140        0.0077             nan     0.0100    0.0000
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0052             nan     0.0100   -0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0428             nan     0.0100    0.0002
##      2        0.0424             nan     0.0100    0.0005
##      3        0.0417             nan     0.0100    0.0005
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0408             nan     0.0100    0.0001
##      6        0.0403             nan     0.0100    0.0005
##      7        0.0399             nan     0.0100    0.0004
##      8        0.0393             nan     0.0100    0.0005
##      9        0.0388             nan     0.0100    0.0002
##     10        0.0383             nan     0.0100    0.0005
##     20        0.0348             nan     0.0100    0.0003
##     40        0.0276             nan     0.0100    0.0000
##     60        0.0225             nan     0.0100   -0.0000
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0159             nan     0.0100    0.0001
##    120        0.0137             nan     0.0100    0.0001
##    140        0.0119             nan     0.0100   -0.0000
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0081             nan     0.0100    0.0000
## 
## - Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.0500    0.0029
##      2        0.0368             nan     0.0500    0.0029
##      3        0.0348             nan     0.0500    0.0016
##      4        0.0334             nan     0.0500    0.0014
##      5        0.0317             nan     0.0500    0.0012
##      6        0.0310             nan     0.0500   -0.0003
##      7        0.0298             nan     0.0500    0.0007
##      8        0.0284             nan     0.0500    0.0009
##      9        0.0268             nan     0.0500    0.0005
##     10        0.0255             nan     0.0500    0.0012
##     20        0.0152             nan     0.0500    0.0008
##     40        0.0065             nan     0.0500    0.0002
##     60        0.0031             nan     0.0500    0.0001
##     80        0.0016             nan     0.0500    0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0005
##      2        0.0385             nan     0.0500    0.0006
##      3        0.0359             nan     0.0500    0.0027
##      4        0.0341             nan     0.0500    0.0014
##      5        0.0320             nan     0.0500    0.0017
##      6        0.0304             nan     0.0500    0.0019
##      7        0.0284             nan     0.0500    0.0020
##      8        0.0271             nan     0.0500    0.0008
##      9        0.0253             nan     0.0500    0.0014
##     10        0.0236             nan     0.0500    0.0016
##     20        0.0149             nan     0.0500    0.0001
##     40        0.0063             nan     0.0500   -0.0000
##     60        0.0033             nan     0.0500    0.0001
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0013             nan     0.0500   -0.0001
##    120        0.0009             nan     0.0500   -0.0000
##    140        0.0006             nan     0.0500   -0.0000
##    160        0.0004             nan     0.0500    0.0000
##    180        0.0003             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0410             nan     0.0500    0.0014
##      2        0.0382             nan     0.0500    0.0027
##      3        0.0354             nan     0.0500    0.0026
##      4        0.0328             nan     0.0500    0.0021
##      5        0.0304             nan     0.0500    0.0018
##      6        0.0289             nan     0.0500    0.0015
##      7        0.0276             nan     0.0500    0.0010
##      8        0.0264             nan     0.0500    0.0007
##      9        0.0252             nan     0.0500    0.0011
##     10        0.0243             nan     0.0500    0.0007
##     20        0.0151             nan     0.0500    0.0004
##     40        0.0074             nan     0.0500   -0.0001
##     60        0.0043             nan     0.0500    0.0000
##     80        0.0026             nan     0.0500   -0.0001
##    100        0.0019             nan     0.0500    0.0000
##    120        0.0012             nan     0.0500    0.0000
##    140        0.0008             nan     0.0500   -0.0000
##    160        0.0006             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0003             nan     0.0500    0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.0500    0.0042
##      2        0.0376             nan     0.0500    0.0021
##      3        0.0356             nan     0.0500    0.0009
##      4        0.0322             nan     0.0500    0.0035
##      5        0.0299             nan     0.0500    0.0010
##      6        0.0276             nan     0.0500    0.0015
##      7        0.0256             nan     0.0500    0.0009
##      8        0.0248             nan     0.0500    0.0007
##      9        0.0231             nan     0.0500    0.0013
##     10        0.0218             nan     0.0500    0.0011
##     20        0.0124             nan     0.0500   -0.0001
##     40        0.0044             nan     0.0500    0.0002
##     60        0.0018             nan     0.0500   -0.0001
##     80        0.0009             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0024
##      2        0.0387             nan     0.0500    0.0009
##      3        0.0372             nan     0.0500    0.0012
##      4        0.0342             nan     0.0500    0.0027
##      5        0.0333             nan     0.0500    0.0003
##      6        0.0307             nan     0.0500    0.0020
##      7        0.0284             nan     0.0500    0.0023
##      8        0.0267             nan     0.0500    0.0011
##      9        0.0249             nan     0.0500    0.0018
##     10        0.0232             nan     0.0500    0.0012
##     20        0.0130             nan     0.0500    0.0004
##     40        0.0046             nan     0.0500    0.0002
##     60        0.0022             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500    0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0404             nan     0.0500    0.0029
##      2        0.0387             nan     0.0500    0.0012
##      3        0.0368             nan     0.0500    0.0019
##      4        0.0357             nan     0.0500    0.0012
##      5        0.0338             nan     0.0500    0.0010
##      6        0.0321             nan     0.0500    0.0008
##      7        0.0300             nan     0.0500    0.0018
##      8        0.0283             nan     0.0500    0.0017
##      9        0.0268             nan     0.0500    0.0010
##     10        0.0251             nan     0.0500    0.0014
##     20        0.0163             nan     0.0500    0.0001
##     40        0.0085             nan     0.0500   -0.0002
##     60        0.0053             nan     0.0500   -0.0001
##     80        0.0036             nan     0.0500    0.0000
##    100        0.0024             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500    0.0000
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0011
##      2        0.0377             nan     0.0500    0.0019
##      3        0.0343             nan     0.0500    0.0019
##      4        0.0321             nan     0.0500    0.0013
##      5        0.0292             nan     0.0500    0.0022
##      6        0.0288             nan     0.0500   -0.0003
##      7        0.0264             nan     0.0500    0.0019
##      8        0.0250             nan     0.0500    0.0012
##      9        0.0233             nan     0.0500    0.0015
##     10        0.0209             nan     0.0500    0.0016
##     20        0.0104             nan     0.0500    0.0006
##     40        0.0031             nan     0.0500    0.0001
##     60        0.0011             nan     0.0500   -0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0000             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.0500    0.0038
##      2        0.0360             nan     0.0500    0.0018
##      3        0.0329             nan     0.0500    0.0026
##      4        0.0298             nan     0.0500    0.0027
##      5        0.0272             nan     0.0500    0.0020
##      6        0.0257             nan     0.0500    0.0014
##      7        0.0241             nan     0.0500    0.0013
##      8        0.0234             nan     0.0500    0.0004
##      9        0.0216             nan     0.0500    0.0009
##     10        0.0201             nan     0.0500    0.0012
##     20        0.0116             nan     0.0500    0.0002
##     40        0.0043             nan     0.0500    0.0001
##     60        0.0022             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0416             nan     0.0500    0.0012
##      2        0.0390             nan     0.0500    0.0026
##      3        0.0365             nan     0.0500    0.0007
##      4        0.0347             nan     0.0500   -0.0000
##      5        0.0327             nan     0.0500    0.0023
##      6        0.0308             nan     0.0500    0.0019
##      7        0.0297             nan     0.0500    0.0001
##      8        0.0286             nan     0.0500    0.0011
##      9        0.0273             nan     0.0500    0.0013
##     10        0.0263             nan     0.0500   -0.0004
##     20        0.0159             nan     0.0500    0.0001
##     40        0.0081             nan     0.0500    0.0002
##     60        0.0045             nan     0.0500    0.0001
##     80        0.0028             nan     0.0500    0.0001
##    100        0.0019             nan     0.0500    0.0000
##    120        0.0013             nan     0.0500   -0.0000
##    140        0.0009             nan     0.0500   -0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500    0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0034
##      2        0.0330             nan     0.1000    0.0045
##      3        0.0284             nan     0.1000    0.0043
##      4        0.0261             nan     0.1000    0.0025
##      5        0.0243             nan     0.1000   -0.0002
##      6        0.0216             nan     0.1000    0.0006
##      7        0.0197             nan     0.1000   -0.0007
##      8        0.0177             nan     0.1000    0.0011
##      9        0.0164             nan     0.1000    0.0009
##     10        0.0153             nan     0.1000    0.0004
##     20        0.0071             nan     0.1000   -0.0002
##     40        0.0019             nan     0.1000    0.0001
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0384             nan     0.1000    0.0047
##      2        0.0348             nan     0.1000    0.0015
##      3        0.0311             nan     0.1000    0.0031
##      4        0.0280             nan     0.1000    0.0019
##      5        0.0264             nan     0.1000    0.0013
##      6        0.0239             nan     0.1000    0.0025
##      7        0.0212             nan     0.1000    0.0022
##      8        0.0208             nan     0.1000   -0.0018
##      9        0.0188             nan     0.1000    0.0018
##     10        0.0169             nan     0.1000    0.0014
##     20        0.0077             nan     0.1000   -0.0000
##     40        0.0031             nan     0.1000    0.0002
##     60        0.0010             nan     0.1000   -0.0000
##     80        0.0004             nan     0.1000    0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.1000    0.0056
##      2        0.0327             nan     0.1000    0.0029
##      3        0.0277             nan     0.1000    0.0040
##      4        0.0243             nan     0.1000    0.0003
##      5        0.0216             nan     0.1000    0.0024
##      6        0.0193             nan     0.1000    0.0022
##      7        0.0178             nan     0.1000    0.0011
##      8        0.0163             nan     0.1000    0.0017
##      9        0.0152             nan     0.1000    0.0002
##     10        0.0134             nan     0.1000    0.0009
##     20        0.0068             nan     0.1000   -0.0001
##     40        0.0030             nan     0.1000    0.0001
##     60        0.0014             nan     0.1000   -0.0001
##     80        0.0008             nan     0.1000   -0.0001
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0359             nan     0.1000    0.0046
##      2        0.0304             nan     0.1000    0.0041
##      3        0.0257             nan     0.1000    0.0045
##      4        0.0232             nan     0.1000    0.0017
##      5        0.0197             nan     0.1000    0.0028
##      6        0.0181             nan     0.1000    0.0005
##      7        0.0174             nan     0.1000   -0.0003
##      8        0.0148             nan     0.1000    0.0023
##      9        0.0130             nan     0.1000    0.0002
##     10        0.0115             nan     0.1000    0.0015
##     20        0.0032             nan     0.1000    0.0002
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0361             nan     0.1000    0.0036
##      2        0.0309             nan     0.1000    0.0045
##      3        0.0296             nan     0.1000   -0.0002
##      4        0.0255             nan     0.1000    0.0021
##      5        0.0210             nan     0.1000    0.0017
##      6        0.0176             nan     0.1000    0.0029
##      7        0.0153             nan     0.1000    0.0019
##      8        0.0140             nan     0.1000    0.0010
##      9        0.0130             nan     0.1000   -0.0002
##     10        0.0120             nan     0.1000    0.0006
##     20        0.0045             nan     0.1000    0.0000
##     40        0.0011             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0395             nan     0.1000    0.0031
##      2        0.0329             nan     0.1000    0.0047
##      3        0.0295             nan     0.1000    0.0013
##      4        0.0256             nan     0.1000    0.0034
##      5        0.0238             nan     0.1000    0.0018
##      6        0.0215             nan     0.1000    0.0022
##      7        0.0197             nan     0.1000    0.0018
##      8        0.0181             nan     0.1000    0.0006
##      9        0.0165             nan     0.1000   -0.0007
##     10        0.0151             nan     0.1000    0.0009
##     20        0.0070             nan     0.1000    0.0001
##     40        0.0026             nan     0.1000   -0.0002
##     60        0.0011             nan     0.1000    0.0000
##     80        0.0005             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0378             nan     0.1000    0.0044
##      2        0.0315             nan     0.1000    0.0019
##      3        0.0277             nan     0.1000    0.0024
##      4        0.0233             nan     0.1000    0.0030
##      5        0.0207             nan     0.1000    0.0020
##      6        0.0192             nan     0.1000    0.0003
##      7        0.0172             nan     0.1000    0.0012
##      8        0.0145             nan     0.1000    0.0020
##      9        0.0126             nan     0.1000    0.0016
##     10        0.0107             nan     0.1000    0.0011
##     20        0.0033             nan     0.1000    0.0000
##     40        0.0005             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0394             nan     0.1000    0.0024
##      2        0.0352             nan     0.1000    0.0023
##      3        0.0307             nan     0.1000    0.0034
##      4        0.0283             nan     0.1000    0.0007
##      5        0.0244             nan     0.1000    0.0039
##      6        0.0217             nan     0.1000    0.0021
##      7        0.0191             nan     0.1000    0.0026
##      8        0.0168             nan     0.1000    0.0007
##      9        0.0154             nan     0.1000    0.0010
##     10        0.0132             nan     0.1000    0.0014
##     20        0.0046             nan     0.1000    0.0005
##     40        0.0011             nan     0.1000    0.0001
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.1000    0.0021
##      2        0.0341             nan     0.1000    0.0048
##      3        0.0310             nan     0.1000    0.0014
##      4        0.0272             nan     0.1000    0.0030
##      5        0.0240             nan     0.1000    0.0027
##      6        0.0222             nan     0.1000    0.0013
##      7        0.0209             nan     0.1000    0.0015
##      8        0.0187             nan     0.1000    0.0019
##      9        0.0178             nan     0.1000    0.0007
##     10        0.0172             nan     0.1000    0.0002
##     20        0.0100             nan     0.1000   -0.0003
##     40        0.0039             nan     0.1000   -0.0001
##     60        0.0019             nan     0.1000    0.0000
##     80        0.0008             nan     0.1000   -0.0001
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.0100    0.0001
##      2        0.0387             nan     0.0100    0.0005
##      3        0.0382             nan     0.0100    0.0003
##      4        0.0378             nan     0.0100    0.0003
##      5        0.0374             nan     0.0100    0.0005
##      6        0.0370             nan     0.0100    0.0003
##      7        0.0366             nan     0.0100    0.0003
##      8        0.0364             nan     0.0100    0.0001
##      9        0.0361             nan     0.0100    0.0000
##     10        0.0357             nan     0.0100    0.0003
##     20        0.0317             nan     0.0100    0.0001
##     40        0.0255             nan     0.0100    0.0002
##     60        0.0205             nan     0.0100    0.0002
##     80        0.0172             nan     0.0100    0.0001
##    100        0.0144             nan     0.0100    0.0001
##    120        0.0119             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0000
##    160        0.0084             nan     0.0100    0.0001
##    180        0.0071             nan     0.0100   -0.0000
##    200        0.0061             nan     0.0100   -0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.0100    0.0002
##      2        0.0386             nan     0.0100    0.0005
##      3        0.0382             nan     0.0100    0.0002
##      4        0.0380             nan     0.0100   -0.0000
##      5        0.0375             nan     0.0100    0.0005
##      6        0.0372             nan     0.0100    0.0002
##      7        0.0366             nan     0.0100    0.0005
##      8        0.0364             nan     0.0100    0.0001
##      9        0.0361             nan     0.0100   -0.0000
##     10        0.0357             nan     0.0100    0.0004
##     20        0.0315             nan     0.0100    0.0002
##     40        0.0256             nan     0.0100    0.0002
##     60        0.0210             nan     0.0100    0.0000
##     80        0.0172             nan     0.0100    0.0002
##    100        0.0146             nan     0.0100    0.0002
##    120        0.0121             nan     0.0100    0.0001
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0086             nan     0.0100    0.0000
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0063             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0390             nan     0.0100    0.0005
##      2        0.0385             nan     0.0100    0.0003
##      3        0.0380             nan     0.0100    0.0005
##      4        0.0377             nan     0.0100    0.0001
##      5        0.0376             nan     0.0100   -0.0000
##      6        0.0372             nan     0.0100   -0.0000
##      7        0.0368             nan     0.0100    0.0002
##      8        0.0363             nan     0.0100    0.0005
##      9        0.0358             nan     0.0100    0.0003
##     10        0.0354             nan     0.0100    0.0003
##     20        0.0316             nan     0.0100    0.0004
##     40        0.0254             nan     0.0100    0.0003
##     60        0.0210             nan     0.0100   -0.0000
##     80        0.0176             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100   -0.0001
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0116             nan     0.0100   -0.0000
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0092             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.0100    0.0003
##      2        0.0386             nan     0.0100    0.0005
##      3        0.0380             nan     0.0100    0.0003
##      4        0.0374             nan     0.0100    0.0004
##      5        0.0371             nan     0.0100    0.0004
##      6        0.0367             nan     0.0100    0.0004
##      7        0.0363             nan     0.0100    0.0003
##      8        0.0360             nan     0.0100    0.0002
##      9        0.0354             nan     0.0100    0.0006
##     10        0.0349             nan     0.0100    0.0004
##     20        0.0309             nan     0.0100    0.0003
##     40        0.0236             nan     0.0100    0.0002
##     60        0.0186             nan     0.0100   -0.0000
##     80        0.0147             nan     0.0100    0.0002
##    100        0.0120             nan     0.0100    0.0000
##    120        0.0093             nan     0.0100    0.0001
##    140        0.0075             nan     0.0100    0.0001
##    160        0.0064             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0041             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0390             nan     0.0100    0.0005
##      2        0.0384             nan     0.0100    0.0005
##      3        0.0381             nan     0.0100    0.0004
##      4        0.0374             nan     0.0100    0.0006
##      5        0.0369             nan     0.0100    0.0005
##      6        0.0364             nan     0.0100    0.0004
##      7        0.0361             nan     0.0100    0.0003
##      8        0.0357             nan     0.0100    0.0003
##      9        0.0354             nan     0.0100    0.0003
##     10        0.0348             nan     0.0100    0.0002
##     20        0.0305             nan     0.0100    0.0004
##     40        0.0236             nan     0.0100    0.0001
##     60        0.0187             nan     0.0100    0.0003
##     80        0.0151             nan     0.0100    0.0001
##    100        0.0123             nan     0.0100    0.0001
##    120        0.0096             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0000
##    160        0.0066             nan     0.0100    0.0000
##    180        0.0056             nan     0.0100    0.0000
##    200        0.0048             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.0100    0.0005
##      2        0.0387             nan     0.0100    0.0005
##      3        0.0385             nan     0.0100   -0.0002
##      4        0.0381             nan     0.0100   -0.0000
##      5        0.0377             nan     0.0100    0.0004
##      6        0.0373             nan     0.0100    0.0002
##      7        0.0368             nan     0.0100    0.0005
##      8        0.0364             nan     0.0100    0.0005
##      9        0.0359             nan     0.0100    0.0005
##     10        0.0356             nan     0.0100    0.0003
##     20        0.0313             nan     0.0100    0.0004
##     40        0.0252             nan     0.0100    0.0003
##     60        0.0208             nan     0.0100    0.0002
##     80        0.0177             nan     0.0100    0.0002
##    100        0.0151             nan     0.0100    0.0001
##    120        0.0129             nan     0.0100    0.0000
##    140        0.0113             nan     0.0100    0.0000
##    160        0.0100             nan     0.0100    0.0001
##    180        0.0089             nan     0.0100    0.0000
##    200        0.0079             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0389             nan     0.0100    0.0003
##      2        0.0385             nan     0.0100    0.0002
##      3        0.0380             nan     0.0100    0.0003
##      4        0.0376             nan     0.0100    0.0004
##      5        0.0369             nan     0.0100    0.0003
##      6        0.0365             nan     0.0100    0.0003
##      7        0.0359             nan     0.0100    0.0006
##      8        0.0353             nan     0.0100    0.0005
##      9        0.0350             nan     0.0100   -0.0000
##     10        0.0345             nan     0.0100    0.0002
##     20        0.0299             nan     0.0100    0.0003
##     40        0.0220             nan     0.0100    0.0003
##     60        0.0166             nan     0.0100    0.0002
##     80        0.0133             nan     0.0100    0.0001
##    100        0.0102             nan     0.0100    0.0000
##    120        0.0082             nan     0.0100    0.0000
##    140        0.0065             nan     0.0100    0.0000
##    160        0.0052             nan     0.0100   -0.0000
##    180        0.0040             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0391             nan     0.0100    0.0002
##      2        0.0384             nan     0.0100    0.0002
##      3        0.0377             nan     0.0100    0.0004
##      4        0.0375             nan     0.0100    0.0000
##      5        0.0370             nan     0.0100    0.0006
##      6        0.0365             nan     0.0100    0.0003
##      7        0.0360             nan     0.0100    0.0003
##      8        0.0355             nan     0.0100    0.0005
##      9        0.0351             nan     0.0100    0.0004
##     10        0.0345             nan     0.0100    0.0005
##     20        0.0307             nan     0.0100    0.0003
##     40        0.0238             nan     0.0100    0.0002
##     60        0.0183             nan     0.0100    0.0001
##     80        0.0143             nan     0.0100    0.0001
##    100        0.0112             nan     0.0100    0.0001
##    120        0.0091             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0001
##    160        0.0061             nan     0.0100    0.0000
##    180        0.0052             nan     0.0100    0.0000
##    200        0.0044             nan     0.0100   -0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0390             nan     0.0100    0.0005
##      2        0.0383             nan     0.0100    0.0006
##      3        0.0379             nan     0.0100    0.0005
##      4        0.0375             nan     0.0100    0.0004
##      5        0.0370             nan     0.0100    0.0005
##      6        0.0365             nan     0.0100    0.0004
##      7        0.0361             nan     0.0100    0.0004
##      8        0.0357             nan     0.0100    0.0002
##      9        0.0354             nan     0.0100    0.0002
##     10        0.0353             nan     0.0100   -0.0001
##     20        0.0315             nan     0.0100    0.0002
##     40        0.0262             nan     0.0100    0.0002
##     60        0.0217             nan     0.0100   -0.0000
##     80        0.0184             nan     0.0100    0.0002
##    100        0.0157             nan     0.0100    0.0000
##    120        0.0137             nan     0.0100   -0.0001
##    140        0.0118             nan     0.0100    0.0000
##    160        0.0105             nan     0.0100    0.0001
##    180        0.0094             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0370             nan     0.0500    0.0014
##      2        0.0347             nan     0.0500    0.0010
##      3        0.0330             nan     0.0500    0.0013
##      4        0.0301             nan     0.0500    0.0025
##      5        0.0285             nan     0.0500    0.0016
##      6        0.0271             nan     0.0500    0.0011
##      7        0.0261             nan     0.0500   -0.0006
##      8        0.0245             nan     0.0500    0.0014
##      9        0.0227             nan     0.0500    0.0018
##     10        0.0213             nan     0.0500    0.0013
##     20        0.0130             nan     0.0500   -0.0002
##     40        0.0055             nan     0.0500    0.0000
##     60        0.0029             nan     0.0500    0.0001
##     80        0.0016             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500    0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0004             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.0500    0.0010
##      2        0.0349             nan     0.0500    0.0023
##      3        0.0320             nan     0.0500    0.0023
##      4        0.0303             nan     0.0500    0.0016
##      5        0.0293             nan     0.0500    0.0008
##      6        0.0282             nan     0.0500    0.0005
##      7        0.0267             nan     0.0500    0.0007
##      8        0.0252             nan     0.0500    0.0015
##      9        0.0239             nan     0.0500    0.0003
##     10        0.0225             nan     0.0500    0.0012
##     20        0.0141             nan     0.0500    0.0005
##     40        0.0063             nan     0.0500    0.0000
##     60        0.0033             nan     0.0500    0.0000
##     80        0.0018             nan     0.0500   -0.0000
##    100        0.0012             nan     0.0500    0.0000
##    120        0.0008             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0365             nan     0.0500    0.0019
##      2        0.0345             nan     0.0500    0.0020
##      3        0.0319             nan     0.0500    0.0021
##      4        0.0301             nan     0.0500    0.0020
##      5        0.0284             nan     0.0500    0.0016
##      6        0.0276             nan     0.0500    0.0006
##      7        0.0268             nan     0.0500    0.0008
##      8        0.0256             nan     0.0500    0.0012
##      9        0.0234             nan     0.0500    0.0013
##     10        0.0222             nan     0.0500    0.0010
##     20        0.0142             nan     0.0500    0.0003
##     40        0.0083             nan     0.0500    0.0002
##     60        0.0054             nan     0.0500    0.0001
##     80        0.0039             nan     0.0500   -0.0000
##    100        0.0027             nan     0.0500    0.0000
##    120        0.0020             nan     0.0500    0.0000
##    140        0.0016             nan     0.0500   -0.0000
##    160        0.0013             nan     0.0500   -0.0000
##    180        0.0010             nan     0.0500   -0.0000
##    200        0.0008             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.0500    0.0025
##      2        0.0343             nan     0.0500    0.0024
##      3        0.0319             nan     0.0500    0.0011
##      4        0.0295             nan     0.0500    0.0006
##      5        0.0275             nan     0.0500    0.0014
##      6        0.0264             nan     0.0500    0.0006
##      7        0.0249             nan     0.0500    0.0006
##      8        0.0235             nan     0.0500    0.0010
##      9        0.0221             nan     0.0500    0.0008
##     10        0.0206             nan     0.0500    0.0010
##     20        0.0105             nan     0.0500    0.0005
##     40        0.0043             nan     0.0500    0.0002
##     60        0.0017             nan     0.0500   -0.0000
##     80        0.0008             nan     0.0500    0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.0500    0.0030
##      2        0.0337             nan     0.0500    0.0027
##      3        0.0316             nan     0.0500    0.0020
##      4        0.0291             nan     0.0500    0.0015
##      5        0.0279             nan     0.0500    0.0011
##      6        0.0256             nan     0.0500    0.0020
##      7        0.0242             nan     0.0500    0.0013
##      8        0.0229             nan     0.0500    0.0007
##      9        0.0218             nan     0.0500    0.0010
##     10        0.0202             nan     0.0500    0.0010
##     20        0.0121             nan     0.0500    0.0001
##     40        0.0060             nan     0.0500   -0.0001
##     60        0.0032             nan     0.0500   -0.0000
##     80        0.0018             nan     0.0500   -0.0000
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500    0.0000
##    160        0.0004             nan     0.0500   -0.0000
##    180        0.0003             nan     0.0500   -0.0000
##    200        0.0002             nan     0.0500    0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0366             nan     0.0500    0.0026
##      2        0.0340             nan     0.0500    0.0024
##      3        0.0325             nan     0.0500    0.0005
##      4        0.0308             nan     0.0500   -0.0003
##      5        0.0289             nan     0.0500    0.0016
##      6        0.0273             nan     0.0500    0.0014
##      7        0.0266             nan     0.0500   -0.0008
##      8        0.0252             nan     0.0500    0.0015
##      9        0.0244             nan     0.0500    0.0006
##     10        0.0229             nan     0.0500    0.0010
##     20        0.0146             nan     0.0500    0.0005
##     40        0.0078             nan     0.0500    0.0001
##     60        0.0050             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500    0.0001
##    100        0.0023             nan     0.0500   -0.0001
##    120        0.0019             nan     0.0500    0.0000
##    140        0.0013             nan     0.0500   -0.0000
##    160        0.0010             nan     0.0500   -0.0000
##    180        0.0008             nan     0.0500   -0.0000
##    200        0.0006             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0373             nan     0.0500    0.0003
##      2        0.0342             nan     0.0500    0.0022
##      3        0.0314             nan     0.0500    0.0016
##      4        0.0294             nan     0.0500    0.0002
##      5        0.0279             nan     0.0500    0.0012
##      6        0.0266             nan     0.0500    0.0001
##      7        0.0257             nan     0.0500   -0.0001
##      8        0.0236             nan     0.0500    0.0021
##      9        0.0221             nan     0.0500    0.0004
##     10        0.0207             nan     0.0500    0.0001
##     20        0.0108             nan     0.0500    0.0000
##     40        0.0032             nan     0.0500    0.0001
##     60        0.0010             nan     0.0500   -0.0000
##     80        0.0004             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0367             nan     0.0500    0.0016
##      2        0.0342             nan     0.0500    0.0026
##      3        0.0310             nan     0.0500    0.0018
##      4        0.0295             nan     0.0500    0.0007
##      5        0.0269             nan     0.0500    0.0012
##      6        0.0252             nan     0.0500    0.0001
##      7        0.0236             nan     0.0500    0.0013
##      8        0.0222             nan     0.0500    0.0014
##      9        0.0206             nan     0.0500    0.0011
##     10        0.0191             nan     0.0500    0.0013
##     20        0.0108             nan     0.0500    0.0005
##     40        0.0048             nan     0.0500    0.0002
##     60        0.0022             nan     0.0500    0.0001
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.0500    0.0018
##      2        0.0358             nan     0.0500    0.0017
##      3        0.0340             nan     0.0500    0.0010
##      4        0.0329             nan     0.0500    0.0010
##      5        0.0312             nan     0.0500    0.0019
##      6        0.0291             nan     0.0500    0.0017
##      7        0.0276             nan     0.0500    0.0015
##      8        0.0270             nan     0.0500   -0.0001
##      9        0.0251             nan     0.0500    0.0016
##     10        0.0238             nan     0.0500    0.0005
##     20        0.0155             nan     0.0500    0.0007
##     40        0.0083             nan     0.0500    0.0001
##     60        0.0057             nan     0.0500   -0.0000
##     80        0.0039             nan     0.0500   -0.0001
##    100        0.0028             nan     0.0500   -0.0000
##    120        0.0023             nan     0.0500   -0.0000
##    140        0.0016             nan     0.0500   -0.0000
##    160        0.0012             nan     0.0500    0.0000
##    180        0.0009             nan     0.0500   -0.0000
##    200        0.0007             nan     0.0500   -0.0000
## 
## - Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0027
##      2        0.0362             nan     0.1000   -0.0015
##      3        0.0323             nan     0.1000    0.0041
##      4        0.0287             nan     0.1000    0.0038
##      5        0.0268             nan     0.1000    0.0021
##      6        0.0235             nan     0.1000    0.0017
##      7        0.0221             nan     0.1000    0.0016
##      8        0.0200             nan     0.1000    0.0018
##      9        0.0181             nan     0.1000    0.0014
##     10        0.0166             nan     0.1000    0.0006
##     20        0.0071             nan     0.1000   -0.0000
##     40        0.0024             nan     0.1000    0.0001
##     60        0.0010             nan     0.1000    0.0000
##     80        0.0004             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0348             nan     0.1000    0.0041
##      2        0.0317             nan     0.1000    0.0001
##      3        0.0282             nan     0.1000    0.0033
##      4        0.0250             nan     0.1000    0.0035
##      5        0.0224             nan     0.1000    0.0020
##      6        0.0212             nan     0.1000    0.0010
##      7        0.0184             nan     0.1000    0.0027
##      8        0.0163             nan     0.1000    0.0015
##      9        0.0148             nan     0.1000    0.0015
##     10        0.0136             nan     0.1000    0.0013
##     20        0.0056             nan     0.1000   -0.0002
##     40        0.0019             nan     0.1000    0.0001
##     60        0.0007             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0343             nan     0.1000    0.0044
##      2        0.0302             nan     0.1000    0.0025
##      3        0.0255             nan     0.1000    0.0035
##      4        0.0224             nan     0.1000    0.0023
##      5        0.0209             nan     0.1000    0.0010
##      6        0.0196             nan     0.1000    0.0009
##      7        0.0173             nan     0.1000    0.0022
##      8        0.0159             nan     0.1000    0.0009
##      9        0.0154             nan     0.1000   -0.0000
##     10        0.0141             nan     0.1000    0.0012
##     20        0.0091             nan     0.1000    0.0001
##     40        0.0039             nan     0.1000   -0.0001
##     60        0.0024             nan     0.1000    0.0000
##     80        0.0017             nan     0.1000   -0.0000
##    100        0.0011             nan     0.1000    0.0001
##    120        0.0007             nan     0.1000   -0.0000
##    140        0.0005             nan     0.1000   -0.0000
##    160        0.0003             nan     0.1000   -0.0000
##    180        0.0002             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0358             nan     0.1000   -0.0012
##      2        0.0317             nan     0.1000    0.0048
##      3        0.0288             nan     0.1000    0.0017
##      4        0.0261             nan     0.1000    0.0017
##      5        0.0223             nan     0.1000    0.0038
##      6        0.0193             nan     0.1000    0.0028
##      7        0.0171             nan     0.1000    0.0017
##      8        0.0148             nan     0.1000    0.0015
##      9        0.0133             nan     0.1000    0.0003
##     10        0.0118             nan     0.1000    0.0009
##     20        0.0040             nan     0.1000    0.0002
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0343             nan     0.1000    0.0015
##      2        0.0322             nan     0.1000    0.0000
##      3        0.0290             nan     0.1000    0.0021
##      4        0.0263             nan     0.1000    0.0005
##      5        0.0231             nan     0.1000    0.0012
##      6        0.0216             nan     0.1000   -0.0010
##      7        0.0197             nan     0.1000    0.0018
##      8        0.0167             nan     0.1000    0.0030
##      9        0.0152             nan     0.1000    0.0017
##     10        0.0141             nan     0.1000    0.0009
##     20        0.0067             nan     0.1000    0.0007
##     40        0.0023             nan     0.1000    0.0001
##     60        0.0011             nan     0.1000   -0.0001
##     80        0.0006             nan     0.1000   -0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0357             nan     0.1000    0.0034
##      2        0.0318             nan     0.1000    0.0017
##      3        0.0282             nan     0.1000    0.0035
##      4        0.0248             nan     0.1000    0.0028
##      5        0.0222             nan     0.1000    0.0021
##      6        0.0197             nan     0.1000    0.0024
##      7        0.0181             nan     0.1000    0.0009
##      8        0.0167             nan     0.1000   -0.0003
##      9        0.0154             nan     0.1000    0.0015
##     10        0.0145             nan     0.1000    0.0003
##     20        0.0080             nan     0.1000    0.0000
##     40        0.0034             nan     0.1000   -0.0000
##     60        0.0015             nan     0.1000    0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000    0.0000
##    140        0.0002             nan     0.1000    0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0355             nan     0.1000    0.0033
##      2        0.0305             nan     0.1000    0.0051
##      3        0.0260             nan     0.1000    0.0033
##      4        0.0227             nan     0.1000    0.0016
##      5        0.0190             nan     0.1000    0.0029
##      6        0.0159             nan     0.1000    0.0020
##      7        0.0136             nan     0.1000    0.0014
##      8        0.0119             nan     0.1000    0.0005
##      9        0.0106             nan     0.1000    0.0009
##     10        0.0092             nan     0.1000    0.0010
##     20        0.0037             nan     0.1000   -0.0000
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000    0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0361             nan     0.1000    0.0009
##      2        0.0309             nan     0.1000    0.0028
##      3        0.0275             nan     0.1000    0.0030
##      4        0.0238             nan     0.1000    0.0023
##      5        0.0211             nan     0.1000    0.0025
##      6        0.0174             nan     0.1000    0.0025
##      7        0.0157             nan     0.1000    0.0003
##      8        0.0131             nan     0.1000    0.0015
##      9        0.0116             nan     0.1000    0.0011
##     10        0.0104             nan     0.1000    0.0015
##     20        0.0041             nan     0.1000    0.0002
##     40        0.0011             nan     0.1000   -0.0001
##     60        0.0003             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.1000    0.0026
##      2        0.0321             nan     0.1000    0.0049
##      3        0.0277             nan     0.1000    0.0029
##      4        0.0242             nan     0.1000    0.0019
##      5        0.0213             nan     0.1000    0.0027
##      6        0.0182             nan     0.1000    0.0012
##      7        0.0164             nan     0.1000    0.0016
##      8        0.0156             nan     0.1000    0.0002
##      9        0.0146             nan     0.1000    0.0006
##     10        0.0135             nan     0.1000    0.0004
##     20        0.0080             nan     0.1000   -0.0000
##     40        0.0031             nan     0.1000   -0.0000
##     60        0.0018             nan     0.1000    0.0000
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0008             nan     0.1000   -0.0000
##    120        0.0005             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0002             nan     0.1000    0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100   -0.0001
##      2        0.0431             nan     0.0100    0.0005
##      3        0.0425             nan     0.0100    0.0006
##      4        0.0420             nan     0.0100    0.0004
##      5        0.0417             nan     0.0100    0.0002
##      6        0.0412             nan     0.0100    0.0004
##      7        0.0407             nan     0.0100    0.0006
##      8        0.0403             nan     0.0100    0.0001
##      9        0.0399             nan     0.0100    0.0004
##     10        0.0393             nan     0.0100    0.0005
##     20        0.0342             nan     0.0100    0.0007
##     40        0.0271             nan     0.0100    0.0003
##     60        0.0223             nan     0.0100    0.0002
##     80        0.0180             nan     0.0100    0.0000
##    100        0.0147             nan     0.0100    0.0001
##    120        0.0120             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0001
##    160        0.0085             nan     0.0100    0.0001
##    180        0.0072             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0005
##      2        0.0428             nan     0.0100    0.0004
##      3        0.0422             nan     0.0100    0.0006
##      4        0.0415             nan     0.0100    0.0006
##      5        0.0410             nan     0.0100    0.0004
##      6        0.0404             nan     0.0100    0.0002
##      7        0.0399             nan     0.0100    0.0006
##      8        0.0396             nan     0.0100    0.0002
##      9        0.0391             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100    0.0005
##     20        0.0344             nan     0.0100    0.0002
##     40        0.0273             nan     0.0100    0.0001
##     60        0.0216             nan     0.0100    0.0002
##     80        0.0174             nan     0.0100    0.0002
##    100        0.0147             nan     0.0100    0.0000
##    120        0.0123             nan     0.0100    0.0001
##    140        0.0105             nan     0.0100    0.0000
##    160        0.0088             nan     0.0100    0.0000
##    180        0.0073             nan     0.0100    0.0000
##    200        0.0062             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0005
##      2        0.0427             nan     0.0100    0.0005
##      3        0.0421             nan     0.0100    0.0005
##      4        0.0417             nan     0.0100    0.0003
##      5        0.0414             nan     0.0100    0.0003
##      6        0.0408             nan     0.0100    0.0006
##      7        0.0403             nan     0.0100    0.0004
##      8        0.0398             nan     0.0100    0.0005
##      9        0.0392             nan     0.0100    0.0005
##     10        0.0388             nan     0.0100    0.0004
##     20        0.0347             nan     0.0100    0.0003
##     40        0.0284             nan     0.0100    0.0003
##     60        0.0225             nan     0.0100    0.0002
##     80        0.0188             nan     0.0100    0.0002
##    100        0.0163             nan     0.0100    0.0000
##    120        0.0138             nan     0.0100    0.0000
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100    0.0000
##    180        0.0092             nan     0.0100    0.0001
##    200        0.0080             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0434             nan     0.0100    0.0002
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0001
##      4        0.0418             nan     0.0100    0.0002
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0007
##      7        0.0401             nan     0.0100    0.0004
##      8        0.0395             nan     0.0100    0.0004
##      9        0.0390             nan     0.0100    0.0004
##     10        0.0386             nan     0.0100    0.0001
##     20        0.0333             nan     0.0100    0.0002
##     40        0.0253             nan     0.0100   -0.0000
##     60        0.0196             nan     0.0100    0.0001
##     80        0.0155             nan     0.0100    0.0001
##    100        0.0121             nan     0.0100    0.0001
##    120        0.0095             nan     0.0100    0.0000
##    140        0.0079             nan     0.0100    0.0000
##    160        0.0064             nan     0.0100   -0.0000
##    180        0.0053             nan     0.0100    0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0100    0.0004
##      2        0.0426             nan     0.0100    0.0004
##      3        0.0419             nan     0.0100    0.0008
##      4        0.0413             nan     0.0100    0.0004
##      5        0.0406             nan     0.0100    0.0005
##      6        0.0401             nan     0.0100    0.0005
##      7        0.0396             nan     0.0100    0.0006
##      8        0.0390             nan     0.0100    0.0005
##      9        0.0386             nan     0.0100    0.0000
##     10        0.0382             nan     0.0100    0.0003
##     20        0.0336             nan     0.0100    0.0003
##     40        0.0260             nan     0.0100    0.0003
##     60        0.0200             nan     0.0100    0.0003
##     80        0.0157             nan     0.0100    0.0002
##    100        0.0124             nan     0.0100    0.0001
##    120        0.0100             nan     0.0100    0.0001
##    140        0.0081             nan     0.0100    0.0001
##    160        0.0070             nan     0.0100    0.0000
##    180        0.0058             nan     0.0100    0.0000
##    200        0.0047             nan     0.0100   -0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0429             nan     0.0100    0.0005
##      3        0.0425             nan     0.0100    0.0003
##      4        0.0420             nan     0.0100    0.0006
##      5        0.0413             nan     0.0100    0.0006
##      6        0.0408             nan     0.0100    0.0005
##      7        0.0402             nan     0.0100    0.0004
##      8        0.0396             nan     0.0100    0.0004
##      9        0.0391             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0005
##     20        0.0343             nan     0.0100    0.0004
##     40        0.0278             nan     0.0100    0.0002
##     60        0.0228             nan     0.0100    0.0002
##     80        0.0190             nan     0.0100   -0.0000
##    100        0.0159             nan     0.0100    0.0001
##    120        0.0136             nan     0.0100    0.0000
##    140        0.0117             nan     0.0100    0.0001
##    160        0.0103             nan     0.0100   -0.0001
##    180        0.0090             nan     0.0100    0.0001
##    200        0.0079             nan     0.0100   -0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0006
##      2        0.0425             nan     0.0100    0.0007
##      3        0.0420             nan     0.0100    0.0003
##      4        0.0414             nan     0.0100    0.0007
##      5        0.0407             nan     0.0100    0.0007
##      6        0.0402             nan     0.0100    0.0004
##      7        0.0394             nan     0.0100    0.0005
##      8        0.0389             nan     0.0100    0.0002
##      9        0.0383             nan     0.0100    0.0005
##     10        0.0376             nan     0.0100    0.0007
##     20        0.0326             nan     0.0100    0.0003
##     40        0.0239             nan     0.0100    0.0004
##     60        0.0185             nan     0.0100   -0.0001
##     80        0.0142             nan     0.0100    0.0001
##    100        0.0110             nan     0.0100    0.0001
##    120        0.0085             nan     0.0100    0.0000
##    140        0.0069             nan     0.0100    0.0000
##    160        0.0054             nan     0.0100    0.0000
##    180        0.0042             nan     0.0100   -0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0432             nan     0.0100    0.0006
##      2        0.0425             nan     0.0100    0.0006
##      3        0.0420             nan     0.0100    0.0004
##      4        0.0412             nan     0.0100    0.0005
##      5        0.0408             nan     0.0100    0.0001
##      6        0.0402             nan     0.0100    0.0006
##      7        0.0395             nan     0.0100    0.0007
##      8        0.0390             nan     0.0100    0.0003
##      9        0.0384             nan     0.0100    0.0004
##     10        0.0378             nan     0.0100    0.0004
##     20        0.0330             nan     0.0100    0.0005
##     40        0.0248             nan     0.0100    0.0002
##     60        0.0195             nan     0.0100    0.0002
##     80        0.0151             nan     0.0100    0.0001
##    100        0.0120             nan     0.0100    0.0001
##    120        0.0094             nan     0.0100    0.0001
##    140        0.0076             nan     0.0100    0.0000
##    160        0.0062             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0433             nan     0.0100    0.0004
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0004
##      4        0.0415             nan     0.0100    0.0005
##      5        0.0408             nan     0.0100    0.0006
##      6        0.0403             nan     0.0100    0.0005
##      7        0.0397             nan     0.0100    0.0001
##      8        0.0395             nan     0.0100    0.0003
##      9        0.0389             nan     0.0100    0.0005
##     10        0.0387             nan     0.0100    0.0001
##     20        0.0346             nan     0.0100    0.0000
##     40        0.0280             nan     0.0100    0.0001
##     60        0.0226             nan     0.0100    0.0003
##     80        0.0191             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0140             nan     0.0100   -0.0000
##    140        0.0121             nan     0.0100    0.0001
##    160        0.0107             nan     0.0100    0.0001
##    180        0.0095             nan     0.0100    0.0000
##    200        0.0085             nan     0.0100    0.0001
## 
## - Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0030
##      2        0.0385             nan     0.0500    0.0023
##      3        0.0359             nan     0.0500    0.0023
##      4        0.0340             nan     0.0500    0.0013
##      5        0.0318             nan     0.0500    0.0008
##      6        0.0305             nan     0.0500    0.0012
##      7        0.0287             nan     0.0500    0.0005
##      8        0.0270             nan     0.0500    0.0015
##      9        0.0255             nan     0.0500    0.0002
##     10        0.0237             nan     0.0500    0.0013
##     20        0.0134             nan     0.0500    0.0003
##     40        0.0056             nan     0.0500    0.0002
##     60        0.0028             nan     0.0500   -0.0000
##     80        0.0015             nan     0.0500    0.0000
##    100        0.0008             nan     0.0500    0.0000
##    120        0.0005             nan     0.0500    0.0000
##    140        0.0003             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0500    0.0026
##      2        0.0383             nan     0.0500    0.0022
##      3        0.0365             nan     0.0500    0.0019
##      4        0.0349             nan     0.0500    0.0011
##      5        0.0339             nan     0.0500   -0.0000
##      6        0.0329             nan     0.0500    0.0008
##      7        0.0304             nan     0.0500    0.0017
##      8        0.0283             nan     0.0500    0.0016
##      9        0.0268             nan     0.0500    0.0011
##     10        0.0256             nan     0.0500    0.0001
##     20        0.0161             nan     0.0500    0.0002
##     40        0.0063             nan     0.0500    0.0000
##     60        0.0031             nan     0.0500   -0.0001
##     80        0.0018             nan     0.0500    0.0000
##    100        0.0011             nan     0.0500   -0.0000
##    120        0.0007             nan     0.0500   -0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500    0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0500    0.0025
##      2        0.0387             nan     0.0500    0.0014
##      3        0.0373             nan     0.0500    0.0003
##      4        0.0348             nan     0.0500    0.0020
##      5        0.0331             nan     0.0500    0.0013
##      6        0.0309             nan     0.0500    0.0022
##      7        0.0300             nan     0.0500    0.0008
##      8        0.0283             nan     0.0500    0.0007
##      9        0.0263             nan     0.0500    0.0016
##     10        0.0258             nan     0.0500    0.0001
##     20        0.0168             nan     0.0500    0.0008
##     40        0.0086             nan     0.0500   -0.0003
##     60        0.0053             nan     0.0500    0.0001
##     80        0.0035             nan     0.0500    0.0001
##    100        0.0025             nan     0.0500    0.0000
##    120        0.0016             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500   -0.0000
##    160        0.0008             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0028
##      2        0.0382             nan     0.0500    0.0013
##      3        0.0367             nan     0.0500    0.0011
##      4        0.0336             nan     0.0500    0.0018
##      5        0.0319             nan     0.0500   -0.0002
##      6        0.0303             nan     0.0500    0.0002
##      7        0.0289             nan     0.0500    0.0007
##      8        0.0265             nan     0.0500    0.0019
##      9        0.0250             nan     0.0500    0.0012
##     10        0.0238             nan     0.0500    0.0001
##     20        0.0126             nan     0.0500    0.0005
##     40        0.0045             nan     0.0500   -0.0000
##     60        0.0017             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500    0.0000
##    100        0.0004             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0418             nan     0.0500    0.0005
##      2        0.0397             nan     0.0500    0.0017
##      3        0.0386             nan     0.0500    0.0009
##      4        0.0357             nan     0.0500    0.0021
##      5        0.0328             nan     0.0500    0.0026
##      6        0.0296             nan     0.0500    0.0017
##      7        0.0285             nan     0.0500   -0.0005
##      8        0.0265             nan     0.0500    0.0013
##      9        0.0253             nan     0.0500    0.0007
##     10        0.0243             nan     0.0500    0.0004
##     20        0.0141             nan     0.0500    0.0009
##     40        0.0046             nan     0.0500    0.0002
##     60        0.0022             nan     0.0500    0.0000
##     80        0.0011             nan     0.0500   -0.0000
##    100        0.0007             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0026
##      2        0.0390             nan     0.0500    0.0024
##      3        0.0375             nan     0.0500    0.0017
##      4        0.0348             nan     0.0500    0.0025
##      5        0.0325             nan     0.0500    0.0021
##      6        0.0310             nan     0.0500    0.0012
##      7        0.0295             nan     0.0500    0.0015
##      8        0.0279             nan     0.0500    0.0009
##      9        0.0267             nan     0.0500    0.0007
##     10        0.0257             nan     0.0500    0.0008
##     20        0.0158             nan     0.0500    0.0007
##     40        0.0075             nan     0.0500    0.0002
##     60        0.0045             nan     0.0500   -0.0001
##     80        0.0031             nan     0.0500   -0.0000
##    100        0.0021             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500    0.0000
##    140        0.0011             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500   -0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.0500    0.0016
##      2        0.0377             nan     0.0500    0.0027
##      3        0.0346             nan     0.0500    0.0029
##      4        0.0315             nan     0.0500    0.0016
##      5        0.0297             nan     0.0500    0.0000
##      6        0.0276             nan     0.0500    0.0004
##      7        0.0261             nan     0.0500    0.0009
##      8        0.0249             nan     0.0500    0.0009
##      9        0.0231             nan     0.0500    0.0019
##     10        0.0221             nan     0.0500    0.0006
##     20        0.0130             nan     0.0500    0.0006
##     40        0.0037             nan     0.0500   -0.0000
##     60        0.0013             nan     0.0500    0.0000
##     80        0.0005             nan     0.0500   -0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0408             nan     0.0500    0.0011
##      2        0.0381             nan     0.0500    0.0015
##      3        0.0361             nan     0.0500    0.0008
##      4        0.0351             nan     0.0500   -0.0000
##      5        0.0328             nan     0.0500    0.0018
##      6        0.0304             nan     0.0500    0.0022
##      7        0.0288             nan     0.0500    0.0009
##      8        0.0275             nan     0.0500    0.0010
##      9        0.0262             nan     0.0500    0.0003
##     10        0.0245             nan     0.0500    0.0015
##     20        0.0121             nan     0.0500    0.0005
##     40        0.0041             nan     0.0500   -0.0000
##     60        0.0018             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500   -0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0431             nan     0.0500   -0.0009
##      2        0.0412             nan     0.0500    0.0024
##      3        0.0386             nan     0.0500    0.0024
##      4        0.0368             nan     0.0500    0.0013
##      5        0.0346             nan     0.0500    0.0020
##      6        0.0330             nan     0.0500    0.0017
##      7        0.0321             nan     0.0500   -0.0012
##      8        0.0315             nan     0.0500   -0.0000
##      9        0.0294             nan     0.0500    0.0016
##     10        0.0276             nan     0.0500    0.0013
##     20        0.0175             nan     0.0500    0.0003
##     40        0.0085             nan     0.0500    0.0002
##     60        0.0047             nan     0.0500    0.0001
##     80        0.0029             nan     0.0500   -0.0000
##    100        0.0019             nan     0.0500   -0.0000
##    120        0.0015             nan     0.0500    0.0000
##    140        0.0010             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0368             nan     0.1000    0.0054
##      2        0.0323             nan     0.1000    0.0002
##      3        0.0291             nan     0.1000    0.0017
##      4        0.0268             nan     0.1000    0.0015
##      5        0.0238             nan     0.1000    0.0033
##      6        0.0214             nan     0.1000    0.0015
##      7        0.0190             nan     0.1000    0.0013
##      8        0.0167             nan     0.1000    0.0007
##      9        0.0152             nan     0.1000    0.0007
##     10        0.0135             nan     0.1000    0.0009
##     20        0.0053             nan     0.1000    0.0000
##     40        0.0015             nan     0.1000   -0.0001
##     60        0.0005             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0399             nan     0.1000    0.0021
##      2        0.0346             nan     0.1000    0.0053
##      3        0.0323             nan     0.1000    0.0020
##      4        0.0288             nan     0.1000    0.0037
##      5        0.0247             nan     0.1000    0.0036
##      6        0.0231             nan     0.1000    0.0014
##      7        0.0215             nan     0.1000    0.0011
##      8        0.0189             nan     0.1000    0.0023
##      9        0.0167             nan     0.1000    0.0018
##     10        0.0148             nan     0.1000    0.0015
##     20        0.0059             nan     0.1000    0.0002
##     40        0.0016             nan     0.1000    0.0000
##     60        0.0008             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0386             nan     0.1000    0.0047
##      2        0.0356             nan     0.1000    0.0024
##      3        0.0327             nan     0.1000    0.0011
##      4        0.0287             nan     0.1000    0.0027
##      5        0.0255             nan     0.1000    0.0034
##      6        0.0227             nan     0.1000    0.0017
##      7        0.0213             nan     0.1000    0.0008
##      8        0.0187             nan     0.1000    0.0015
##      9        0.0168             nan     0.1000    0.0021
##     10        0.0156             nan     0.1000    0.0016
##     20        0.0083             nan     0.1000   -0.0002
##     40        0.0033             nan     0.1000   -0.0000
##     60        0.0015             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.1000    0.0009
##      2        0.0333             nan     0.1000    0.0053
##      3        0.0277             nan     0.1000    0.0049
##      4        0.0260             nan     0.1000   -0.0010
##      5        0.0215             nan     0.1000    0.0042
##      6        0.0180             nan     0.1000    0.0034
##      7        0.0156             nan     0.1000    0.0012
##      8        0.0128             nan     0.1000    0.0021
##      9        0.0108             nan     0.1000    0.0014
##     10        0.0100             nan     0.1000    0.0008
##     20        0.0030             nan     0.1000   -0.0000
##     40        0.0007             nan     0.1000   -0.0000
##     60        0.0003             nan     0.1000    0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000    0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0402             nan     0.1000    0.0005
##      2        0.0361             nan     0.1000    0.0029
##      3        0.0307             nan     0.1000    0.0047
##      4        0.0263             nan     0.1000    0.0028
##      5        0.0223             nan     0.1000    0.0031
##      6        0.0201             nan     0.1000   -0.0002
##      7        0.0194             nan     0.1000   -0.0002
##      8        0.0171             nan     0.1000    0.0011
##      9        0.0146             nan     0.1000    0.0023
##     10        0.0136             nan     0.1000    0.0005
##     20        0.0043             nan     0.1000    0.0003
##     40        0.0011             nan     0.1000    0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.1000    0.0030
##      2        0.0360             nan     0.1000    0.0026
##      3        0.0315             nan     0.1000    0.0039
##      4        0.0274             nan     0.1000    0.0029
##      5        0.0234             nan     0.1000    0.0026
##      6        0.0207             nan     0.1000    0.0022
##      7        0.0184             nan     0.1000    0.0018
##      8        0.0178             nan     0.1000    0.0004
##      9        0.0168             nan     0.1000    0.0008
##     10        0.0156             nan     0.1000    0.0002
##     20        0.0080             nan     0.1000    0.0001
##     40        0.0032             nan     0.1000   -0.0002
##     60        0.0022             nan     0.1000   -0.0002
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0031
##      2        0.0352             nan     0.1000   -0.0004
##      3        0.0306             nan     0.1000    0.0026
##      4        0.0265             nan     0.1000    0.0026
##      5        0.0234             nan     0.1000    0.0035
##      6        0.0204             nan     0.1000    0.0019
##      7        0.0180             nan     0.1000    0.0015
##      8        0.0151             nan     0.1000    0.0016
##      9        0.0132             nan     0.1000    0.0008
##     10        0.0113             nan     0.1000    0.0010
##     20        0.0040             nan     0.1000    0.0005
##     40        0.0004             nan     0.1000   -0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.1000    0.0024
##      2        0.0348             nan     0.1000    0.0023
##      3        0.0289             nan     0.1000    0.0048
##      4        0.0245             nan     0.1000    0.0030
##      5        0.0216             nan     0.1000    0.0027
##      6        0.0183             nan     0.1000    0.0017
##      7        0.0158             nan     0.1000    0.0007
##      8        0.0139             nan     0.1000   -0.0006
##      9        0.0122             nan     0.1000    0.0009
##     10        0.0110             nan     0.1000    0.0012
##     20        0.0040             nan     0.1000   -0.0003
##     40        0.0009             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0375             nan     0.1000    0.0051
##      2        0.0333             nan     0.1000    0.0036
##      3        0.0289             nan     0.1000    0.0037
##      4        0.0268             nan     0.1000    0.0020
##      5        0.0251             nan     0.1000    0.0008
##      6        0.0231             nan     0.1000    0.0003
##      7        0.0210             nan     0.1000    0.0020
##      8        0.0199             nan     0.1000    0.0009
##      9        0.0188             nan     0.1000    0.0011
##     10        0.0177             nan     0.1000    0.0009
##     20        0.0091             nan     0.1000    0.0001
##     40        0.0033             nan     0.1000   -0.0000
##     60        0.0015             nan     0.1000    0.0000
##     80        0.0008             nan     0.1000    0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0007
##      2        0.0428             nan     0.0100    0.0006
##      3        0.0423             nan     0.0100    0.0002
##      4        0.0416             nan     0.0100    0.0005
##      5        0.0409             nan     0.0100    0.0004
##      6        0.0405             nan     0.0100    0.0002
##      7        0.0401             nan     0.0100    0.0001
##      8        0.0395             nan     0.0100    0.0006
##      9        0.0391             nan     0.0100    0.0001
##     10        0.0387             nan     0.0100    0.0004
##     20        0.0344             nan     0.0100   -0.0000
##     40        0.0274             nan     0.0100    0.0001
##     60        0.0225             nan     0.0100    0.0001
##     80        0.0187             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100   -0.0000
##    120        0.0128             nan     0.0100    0.0001
##    140        0.0109             nan     0.0100    0.0000
##    160        0.0091             nan     0.0100   -0.0000
##    180        0.0076             nan     0.0100    0.0001
##    200        0.0065             nan     0.0100    0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0002
##      2        0.0431             nan     0.0100    0.0005
##      3        0.0427             nan     0.0100    0.0002
##      4        0.0422             nan     0.0100    0.0004
##      5        0.0417             nan     0.0100    0.0003
##      6        0.0412             nan     0.0100    0.0006
##      7        0.0405             nan     0.0100    0.0004
##      8        0.0403             nan     0.0100    0.0002
##      9        0.0398             nan     0.0100    0.0003
##     10        0.0393             nan     0.0100    0.0004
##     20        0.0351             nan     0.0100    0.0002
##     40        0.0281             nan     0.0100    0.0004
##     60        0.0225             nan     0.0100    0.0003
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100    0.0002
##    120        0.0125             nan     0.0100    0.0001
##    140        0.0105             nan     0.0100    0.0000
##    160        0.0089             nan     0.0100    0.0000
##    180        0.0076             nan     0.0100    0.0001
##    200        0.0065             nan     0.0100    0.0001
## 
## - Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0004
##      2        0.0431             nan     0.0100    0.0006
##      3        0.0425             nan     0.0100    0.0004
##      4        0.0420             nan     0.0100    0.0006
##      5        0.0415             nan     0.0100    0.0003
##      6        0.0411             nan     0.0100    0.0003
##      7        0.0406             nan     0.0100    0.0002
##      8        0.0401             nan     0.0100    0.0005
##      9        0.0398             nan     0.0100    0.0001
##     10        0.0393             nan     0.0100    0.0005
##     20        0.0345             nan     0.0100    0.0004
##     40        0.0279             nan     0.0100   -0.0000
##     60        0.0224             nan     0.0100    0.0001
##     80        0.0185             nan     0.0100   -0.0000
##    100        0.0156             nan     0.0100    0.0000
##    120        0.0132             nan     0.0100    0.0001
##    140        0.0114             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100    0.0000
##    180        0.0086             nan     0.0100    0.0000
##    200        0.0076             nan     0.0100   -0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0437             nan     0.0100    0.0007
##      2        0.0427             nan     0.0100    0.0006
##      3        0.0422             nan     0.0100    0.0004
##      4        0.0416             nan     0.0100    0.0005
##      5        0.0410             nan     0.0100    0.0005
##      6        0.0406             nan     0.0100    0.0003
##      7        0.0401             nan     0.0100    0.0000
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0390             nan     0.0100    0.0004
##     10        0.0383             nan     0.0100    0.0006
##     20        0.0334             nan     0.0100   -0.0000
##     40        0.0253             nan     0.0100    0.0002
##     60        0.0193             nan     0.0100    0.0003
##     80        0.0153             nan     0.0100    0.0002
##    100        0.0122             nan     0.0100   -0.0000
##    120        0.0096             nan     0.0100    0.0000
##    140        0.0077             nan     0.0100    0.0000
##    160        0.0062             nan     0.0100    0.0000
##    180        0.0050             nan     0.0100    0.0001
##    200        0.0039             nan     0.0100   -0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0435             nan     0.0100    0.0007
##      2        0.0431             nan     0.0100    0.0001
##      3        0.0425             nan     0.0100    0.0005
##      4        0.0419             nan     0.0100    0.0004
##      5        0.0413             nan     0.0100    0.0006
##      6        0.0405             nan     0.0100    0.0005
##      7        0.0401             nan     0.0100    0.0001
##      8        0.0397             nan     0.0100    0.0003
##      9        0.0391             nan     0.0100    0.0004
##     10        0.0387             nan     0.0100    0.0003
##     20        0.0339             nan     0.0100    0.0002
##     40        0.0256             nan     0.0100    0.0004
##     60        0.0199             nan     0.0100    0.0002
##     80        0.0155             nan     0.0100    0.0002
##    100        0.0125             nan     0.0100    0.0001
##    120        0.0097             nan     0.0100    0.0001
##    140        0.0081             nan     0.0100   -0.0000
##    160        0.0064             nan     0.0100    0.0001
##    180        0.0053             nan     0.0100    0.0000
##    200        0.0044             nan     0.0100    0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0439             nan     0.0100   -0.0000
##      2        0.0432             nan     0.0100    0.0006
##      3        0.0426             nan     0.0100    0.0005
##      4        0.0423             nan     0.0100    0.0003
##      5        0.0419             nan     0.0100    0.0004
##      6        0.0417             nan     0.0100   -0.0001
##      7        0.0412             nan     0.0100    0.0004
##      8        0.0410             nan     0.0100   -0.0000
##      9        0.0404             nan     0.0100    0.0003
##     10        0.0399             nan     0.0100    0.0003
##     20        0.0350             nan     0.0100    0.0005
##     40        0.0293             nan     0.0100    0.0003
##     60        0.0242             nan     0.0100    0.0001
##     80        0.0199             nan     0.0100    0.0001
##    100        0.0166             nan     0.0100    0.0001
##    120        0.0141             nan     0.0100    0.0000
##    140        0.0117             nan     0.0100    0.0000
##    160        0.0101             nan     0.0100    0.0000
##    180        0.0093             nan     0.0100    0.0000
##    200        0.0085             nan     0.0100   -0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0004
##      2        0.0430             nan     0.0100    0.0005
##      3        0.0424             nan     0.0100    0.0001
##      4        0.0418             nan     0.0100    0.0004
##      5        0.0414             nan     0.0100    0.0002
##      6        0.0406             nan     0.0100    0.0007
##      7        0.0402             nan     0.0100    0.0003
##      8        0.0396             nan     0.0100    0.0006
##      9        0.0388             nan     0.0100    0.0007
##     10        0.0382             nan     0.0100    0.0004
##     20        0.0329             nan     0.0100    0.0005
##     40        0.0248             nan     0.0100    0.0003
##     60        0.0188             nan     0.0100    0.0002
##     80        0.0141             nan     0.0100    0.0001
##    100        0.0108             nan     0.0100   -0.0000
##    120        0.0084             nan     0.0100    0.0001
##    140        0.0064             nan     0.0100    0.0001
##    160        0.0052             nan     0.0100   -0.0000
##    180        0.0040             nan     0.0100    0.0000
##    200        0.0033             nan     0.0100    0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0436             nan     0.0100    0.0004
##      2        0.0430             nan     0.0100    0.0005
##      3        0.0423             nan     0.0100    0.0006
##      4        0.0419             nan     0.0100    0.0002
##      5        0.0413             nan     0.0100    0.0005
##      6        0.0407             nan     0.0100    0.0005
##      7        0.0400             nan     0.0100    0.0008
##      8        0.0395             nan     0.0100    0.0005
##      9        0.0389             nan     0.0100    0.0004
##     10        0.0383             nan     0.0100    0.0005
##     20        0.0333             nan     0.0100    0.0005
##     40        0.0249             nan     0.0100    0.0002
##     60        0.0195             nan     0.0100    0.0003
##     80        0.0149             nan     0.0100    0.0002
##    100        0.0117             nan     0.0100   -0.0000
##    120        0.0092             nan     0.0100    0.0001
##    140        0.0076             nan     0.0100    0.0000
##    160        0.0063             nan     0.0100    0.0000
##    180        0.0051             nan     0.0100    0.0000
##    200        0.0043             nan     0.0100    0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0438             nan     0.0100    0.0006
##      2        0.0432             nan     0.0100    0.0003
##      3        0.0426             nan     0.0100    0.0005
##      4        0.0421             nan     0.0100    0.0003
##      5        0.0416             nan     0.0100    0.0002
##      6        0.0412             nan     0.0100    0.0004
##      7        0.0408             nan     0.0100    0.0003
##      8        0.0403             nan     0.0100    0.0002
##      9        0.0400             nan     0.0100    0.0000
##     10        0.0396             nan     0.0100    0.0004
##     20        0.0353             nan     0.0100    0.0005
##     40        0.0283             nan     0.0100    0.0004
##     60        0.0225             nan     0.0100    0.0003
##     80        0.0192             nan     0.0100    0.0001
##    100        0.0161             nan     0.0100    0.0001
##    120        0.0139             nan     0.0100    0.0000
##    140        0.0122             nan     0.0100    0.0000
##    160        0.0107             nan     0.0100    0.0000
##    180        0.0093             nan     0.0100    0.0000
##    200        0.0084             nan     0.0100    0.0000
## 
## - Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.0500    0.0007
##      2        0.0398             nan     0.0500    0.0019
##      3        0.0371             nan     0.0500    0.0023
##      4        0.0348             nan     0.0500    0.0024
##      5        0.0325             nan     0.0500    0.0015
##      6        0.0304             nan     0.0500    0.0003
##      7        0.0286             nan     0.0500    0.0017
##      8        0.0264             nan     0.0500    0.0017
##      9        0.0248             nan     0.0500    0.0013
##     10        0.0232             nan     0.0500    0.0013
##     20        0.0141             nan     0.0500    0.0001
##     40        0.0053             nan     0.0500    0.0002
##     60        0.0025             nan     0.0500    0.0001
##     80        0.0014             nan     0.0500   -0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0412             nan     0.0500    0.0029
##      2        0.0385             nan     0.0500    0.0023
##      3        0.0353             nan     0.0500    0.0026
##      4        0.0329             nan     0.0500    0.0013
##      5        0.0311             nan     0.0500    0.0018
##      6        0.0290             nan     0.0500    0.0020
##      7        0.0270             nan     0.0500    0.0016
##      8        0.0250             nan     0.0500    0.0016
##      9        0.0240             nan     0.0500    0.0006
##     10        0.0228             nan     0.0500    0.0007
##     20        0.0150             nan     0.0500   -0.0002
##     40        0.0064             nan     0.0500    0.0002
##     60        0.0032             nan     0.0500    0.0001
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500   -0.0000
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500    0.0000
##    160        0.0004             nan     0.0500    0.0000
##    180        0.0003             nan     0.0500    0.0000
##    200        0.0002             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0027
##      2        0.0388             nan     0.0500    0.0009
##      3        0.0356             nan     0.0500    0.0021
##      4        0.0331             nan     0.0500    0.0023
##      5        0.0314             nan     0.0500    0.0012
##      6        0.0299             nan     0.0500    0.0018
##      7        0.0286             nan     0.0500    0.0014
##      8        0.0267             nan     0.0500    0.0015
##      9        0.0257             nan     0.0500   -0.0001
##     10        0.0246             nan     0.0500    0.0009
##     20        0.0156             nan     0.0500   -0.0001
##     40        0.0082             nan     0.0500    0.0002
##     60        0.0054             nan     0.0500    0.0000
##     80        0.0035             nan     0.0500   -0.0000
##    100        0.0026             nan     0.0500   -0.0000
##    120        0.0018             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500    0.0000
##    160        0.0008             nan     0.0500    0.0000
##    180        0.0006             nan     0.0500   -0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0421             nan     0.0500    0.0006
##      2        0.0399             nan     0.0500    0.0011
##      3        0.0366             nan     0.0500    0.0012
##      4        0.0339             nan     0.0500    0.0021
##      5        0.0320             nan     0.0500    0.0017
##      6        0.0288             nan     0.0500    0.0029
##      7        0.0278             nan     0.0500    0.0007
##      8        0.0255             nan     0.0500    0.0013
##      9        0.0244             nan     0.0500    0.0004
##     10        0.0227             nan     0.0500    0.0006
##     20        0.0119             nan     0.0500    0.0004
##     40        0.0041             nan     0.0500    0.0001
##     60        0.0016             nan     0.0500    0.0001
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500    0.0000
##    180        0.0000             nan     0.0500    0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0034
##      2        0.0380             nan     0.0500    0.0008
##      3        0.0357             nan     0.0500    0.0016
##      4        0.0336             nan     0.0500    0.0006
##      5        0.0312             nan     0.0500    0.0021
##      6        0.0289             nan     0.0500    0.0008
##      7        0.0264             nan     0.0500    0.0015
##      8        0.0246             nan     0.0500    0.0018
##      9        0.0229             nan     0.0500    0.0012
##     10        0.0224             nan     0.0500   -0.0004
##     20        0.0129             nan     0.0500    0.0003
##     40        0.0050             nan     0.0500    0.0001
##     60        0.0019             nan     0.0500    0.0001
##     80        0.0008             nan     0.0500   -0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0410             nan     0.0500    0.0023
##      2        0.0392             nan     0.0500    0.0016
##      3        0.0366             nan     0.0500    0.0021
##      4        0.0348             nan     0.0500    0.0019
##      5        0.0329             nan     0.0500    0.0021
##      6        0.0313             nan     0.0500    0.0013
##      7        0.0296             nan     0.0500    0.0010
##      8        0.0287             nan     0.0500    0.0009
##      9        0.0273             nan     0.0500    0.0014
##     10        0.0263             nan     0.0500    0.0004
##     20        0.0150             nan     0.0500    0.0005
##     40        0.0072             nan     0.0500    0.0002
##     60        0.0042             nan     0.0500    0.0001
##     80        0.0026             nan     0.0500    0.0001
##    100        0.0019             nan     0.0500    0.0000
##    120        0.0013             nan     0.0500   -0.0000
##    140        0.0009             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500    0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500    0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.0500    0.0017
##      2        0.0391             nan     0.0500   -0.0000
##      3        0.0369             nan     0.0500    0.0014
##      4        0.0345             nan     0.0500    0.0020
##      5        0.0317             nan     0.0500    0.0011
##      6        0.0303             nan     0.0500    0.0011
##      7        0.0281             nan     0.0500    0.0015
##      8        0.0265             nan     0.0500    0.0019
##      9        0.0242             nan     0.0500    0.0022
##     10        0.0227             nan     0.0500    0.0009
##     20        0.0116             nan     0.0500    0.0002
##     40        0.0031             nan     0.0500    0.0001
##     60        0.0012             nan     0.0500   -0.0000
##     80        0.0005             nan     0.0500    0.0000
##    100        0.0002             nan     0.0500   -0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500    0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0409             nan     0.0500    0.0029
##      2        0.0385             nan     0.0500    0.0022
##      3        0.0363             nan     0.0500    0.0006
##      4        0.0342             nan     0.0500    0.0018
##      5        0.0307             nan     0.0500    0.0022
##      6        0.0285             nan     0.0500    0.0014
##      7        0.0266             nan     0.0500    0.0021
##      8        0.0251             nan     0.0500    0.0015
##      9        0.0239             nan     0.0500    0.0008
##     10        0.0230             nan     0.0500    0.0000
##     20        0.0113             nan     0.0500    0.0007
##     40        0.0036             nan     0.0500    0.0001
##     60        0.0016             nan     0.0500   -0.0000
##     80        0.0010             nan     0.0500    0.0000
##    100        0.0005             nan     0.0500    0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500   -0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0414             nan     0.0500    0.0011
##      2        0.0390             nan     0.0500    0.0009
##      3        0.0364             nan     0.0500    0.0026
##      4        0.0345             nan     0.0500    0.0005
##      5        0.0334             nan     0.0500    0.0000
##      6        0.0311             nan     0.0500    0.0021
##      7        0.0300             nan     0.0500    0.0011
##      8        0.0288             nan     0.0500    0.0002
##      9        0.0273             nan     0.0500    0.0016
##     10        0.0268             nan     0.0500   -0.0003
##     20        0.0165             nan     0.0500    0.0008
##     40        0.0094             nan     0.0500    0.0000
##     60        0.0060             nan     0.0500    0.0002
##     80        0.0036             nan     0.0500    0.0000
##    100        0.0023             nan     0.0500    0.0000
##    120        0.0017             nan     0.0500   -0.0001
##    140        0.0012             nan     0.0500    0.0000
##    160        0.0007             nan     0.0500   -0.0000
##    180        0.0005             nan     0.0500   -0.0000
##    200        0.0004             nan     0.0500   -0.0000
## 
## - Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0413             nan     0.1000    0.0032
##      2        0.0398             nan     0.1000   -0.0010
##      3        0.0368             nan     0.1000    0.0003
##      4        0.0335             nan     0.1000    0.0027
##      5        0.0298             nan     0.1000    0.0032
##      6        0.0266             nan     0.1000    0.0029
##      7        0.0247             nan     0.1000    0.0008
##      8        0.0219             nan     0.1000    0.0025
##      9        0.0196             nan     0.1000    0.0002
##     10        0.0171             nan     0.1000    0.0020
##     20        0.0085             nan     0.1000    0.0007
##     40        0.0022             nan     0.1000   -0.0000
##     60        0.0007             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.1000    0.0030
##      2        0.0364             nan     0.1000    0.0000
##      3        0.0312             nan     0.1000    0.0033
##      4        0.0292             nan     0.1000    0.0006
##      5        0.0252             nan     0.1000    0.0034
##      6        0.0225             nan     0.1000    0.0022
##      7        0.0200             nan     0.1000    0.0025
##      8        0.0179             nan     0.1000    0.0017
##      9        0.0169             nan     0.1000    0.0010
##     10        0.0155             nan     0.1000    0.0010
##     20        0.0064             nan     0.1000    0.0006
##     40        0.0018             nan     0.1000    0.0001
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0411             nan     0.1000    0.0016
##      2        0.0346             nan     0.1000    0.0053
##      3        0.0306             nan     0.1000    0.0010
##      4        0.0273             nan     0.1000    0.0018
##      5        0.0234             nan     0.1000    0.0031
##      6        0.0213             nan     0.1000    0.0022
##      7        0.0192             nan     0.1000    0.0006
##      8        0.0180             nan     0.1000    0.0011
##      9        0.0158             nan     0.1000    0.0016
##     10        0.0142             nan     0.1000    0.0017
##     20        0.0066             nan     0.1000    0.0003
##     40        0.0021             nan     0.1000   -0.0001
##     60        0.0011             nan     0.1000    0.0000
##     80        0.0006             nan     0.1000    0.0000
##    100        0.0003             nan     0.1000   -0.0000
##    120        0.0002             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0393             nan     0.1000   -0.0000
##      2        0.0325             nan     0.1000    0.0071
##      3        0.0272             nan     0.1000    0.0046
##      4        0.0228             nan     0.1000    0.0031
##      5        0.0199             nan     0.1000    0.0013
##      6        0.0176             nan     0.1000    0.0025
##      7        0.0144             nan     0.1000    0.0018
##      8        0.0122             nan     0.1000    0.0012
##      9        0.0100             nan     0.1000    0.0014
##     10        0.0089             nan     0.1000    0.0007
##     20        0.0026             nan     0.1000    0.0002
##     40        0.0006             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0383             nan     0.1000    0.0057
##      2        0.0330             nan     0.1000    0.0045
##      3        0.0288             nan     0.1000    0.0045
##      4        0.0263             nan     0.1000    0.0011
##      5        0.0226             nan     0.1000    0.0023
##      6        0.0205             nan     0.1000    0.0003
##      7        0.0187             nan     0.1000    0.0010
##      8        0.0161             nan     0.1000    0.0006
##      9        0.0148             nan     0.1000    0.0015
##     10        0.0141             nan     0.1000    0.0006
##     20        0.0045             nan     0.1000    0.0003
##     40        0.0013             nan     0.1000   -0.0000
##     60        0.0005             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000    0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0387             nan     0.1000    0.0061
##      2        0.0353             nan     0.1000    0.0031
##      3        0.0318             nan     0.1000    0.0025
##      4        0.0280             nan     0.1000    0.0038
##      5        0.0243             nan     0.1000    0.0026
##      6        0.0211             nan     0.1000    0.0018
##      7        0.0194             nan     0.1000    0.0012
##      8        0.0178             nan     0.1000    0.0007
##      9        0.0160             nan     0.1000    0.0017
##     10        0.0156             nan     0.1000   -0.0005
##     20        0.0084             nan     0.1000    0.0003
##     40        0.0035             nan     0.1000   -0.0003
##     60        0.0016             nan     0.1000    0.0000
##     80        0.0009             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000    0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.1000    0.0021
##      2        0.0331             nan     0.1000    0.0035
##      3        0.0280             nan     0.1000    0.0023
##      4        0.0237             nan     0.1000    0.0025
##      5        0.0205             nan     0.1000    0.0024
##      6        0.0173             nan     0.1000    0.0027
##      7        0.0146             nan     0.1000    0.0026
##      8        0.0124             nan     0.1000    0.0016
##      9        0.0109             nan     0.1000    0.0008
##     10        0.0096             nan     0.1000    0.0002
##     20        0.0029             nan     0.1000    0.0001
##     40        0.0006             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000    0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000    0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000    0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0390             nan     0.1000    0.0048
##      2        0.0353             nan     0.1000    0.0032
##      3        0.0310             nan     0.1000    0.0020
##      4        0.0263             nan     0.1000    0.0047
##      5        0.0220             nan     0.1000    0.0039
##      6        0.0196             nan     0.1000    0.0027
##      7        0.0176             nan     0.1000    0.0013
##      8        0.0158             nan     0.1000    0.0017
##      9        0.0141             nan     0.1000    0.0010
##     10        0.0128             nan     0.1000    0.0014
##     20        0.0046             nan     0.1000   -0.0007
##     40        0.0011             nan     0.1000   -0.0000
##     60        0.0004             nan     0.1000   -0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.1000    0.0056
##      2        0.0336             nan     0.1000    0.0019
##      3        0.0294             nan     0.1000    0.0040
##      4        0.0271             nan     0.1000    0.0006
##      5        0.0241             nan     0.1000    0.0033
##      6        0.0212             nan     0.1000    0.0028
##      7        0.0189             nan     0.1000    0.0011
##      8        0.0174             nan     0.1000    0.0005
##      9        0.0161             nan     0.1000    0.0005
##     10        0.0154             nan     0.1000    0.0009
##     20        0.0075             nan     0.1000   -0.0003
##     40        0.0030             nan     0.1000   -0.0001
##     60        0.0014             nan     0.1000   -0.0000
##     80        0.0008             nan     0.1000   -0.0000
##    100        0.0005             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0001             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0407             nan     0.0100    0.0003
##      2        0.0402             nan     0.0100    0.0005
##      3        0.0397             nan     0.0100    0.0006
##      4        0.0392             nan     0.0100    0.0003
##      5        0.0387             nan     0.0100    0.0005
##      6        0.0383             nan     0.0100    0.0006
##      7        0.0378             nan     0.0100    0.0005
##      8        0.0373             nan     0.0100    0.0001
##      9        0.0369             nan     0.0100    0.0004
##     10        0.0365             nan     0.0100    0.0002
##     20        0.0324             nan     0.0100    0.0004
##     40        0.0269             nan     0.0100    0.0005
##     60        0.0219             nan     0.0100    0.0001
##     80        0.0180             nan     0.0100    0.0000
##    100        0.0149             nan     0.0100    0.0002
##    120        0.0121             nan     0.0100    0.0001
##    140        0.0101             nan     0.0100    0.0001
##    160        0.0083             nan     0.0100   -0.0000
##    180        0.0070             nan     0.0100    0.0001
##    200        0.0058             nan     0.0100    0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0100    0.0005
##      2        0.0401             nan     0.0100    0.0003
##      3        0.0395             nan     0.0100    0.0007
##      4        0.0390             nan     0.0100    0.0004
##      5        0.0387             nan     0.0100    0.0001
##      6        0.0382             nan     0.0100    0.0004
##      7        0.0378             nan     0.0100    0.0002
##      8        0.0374             nan     0.0100    0.0002
##      9        0.0370             nan     0.0100    0.0003
##     10        0.0366             nan     0.0100    0.0004
##     20        0.0330             nan     0.0100    0.0001
##     40        0.0264             nan     0.0100    0.0001
##     60        0.0214             nan     0.0100    0.0001
##     80        0.0178             nan     0.0100    0.0001
##    100        0.0146             nan     0.0100    0.0000
##    120        0.0121             nan     0.0100    0.0000
##    140        0.0102             nan     0.0100    0.0001
##    160        0.0089             nan     0.0100   -0.0001
##    180        0.0077             nan     0.0100    0.0001
##    200        0.0066             nan     0.0100    0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0100    0.0005
##      2        0.0402             nan     0.0100    0.0002
##      3        0.0399             nan     0.0100   -0.0001
##      4        0.0394             nan     0.0100    0.0005
##      5        0.0389             nan     0.0100    0.0005
##      6        0.0384             nan     0.0100    0.0002
##      7        0.0381             nan     0.0100    0.0003
##      8        0.0375             nan     0.0100    0.0005
##      9        0.0370             nan     0.0100    0.0005
##     10        0.0366             nan     0.0100    0.0004
##     20        0.0327             nan     0.0100    0.0002
##     40        0.0266             nan     0.0100    0.0001
##     60        0.0221             nan     0.0100    0.0002
##     80        0.0183             nan     0.0100    0.0001
##    100        0.0156             nan     0.0100    0.0000
##    120        0.0137             nan     0.0100    0.0000
##    140        0.0121             nan     0.0100   -0.0000
##    160        0.0106             nan     0.0100    0.0000
##    180        0.0094             nan     0.0100    0.0000
##    200        0.0085             nan     0.0100    0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0006
##      2        0.0399             nan     0.0100    0.0000
##      3        0.0394             nan     0.0100    0.0006
##      4        0.0387             nan     0.0100    0.0009
##      5        0.0380             nan     0.0100    0.0005
##      6        0.0375             nan     0.0100    0.0002
##      7        0.0370             nan     0.0100    0.0003
##      8        0.0365             nan     0.0100    0.0004
##      9        0.0361             nan     0.0100    0.0005
##     10        0.0356             nan     0.0100    0.0004
##     20        0.0311             nan     0.0100    0.0002
##     40        0.0241             nan     0.0100    0.0003
##     60        0.0182             nan     0.0100    0.0001
##     80        0.0138             nan     0.0100    0.0002
##    100        0.0113             nan     0.0100   -0.0001
##    120        0.0089             nan     0.0100    0.0001
##    140        0.0074             nan     0.0100    0.0001
##    160        0.0060             nan     0.0100    0.0000
##    180        0.0049             nan     0.0100    0.0000
##    200        0.0040             nan     0.0100    0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0100    0.0006
##      2        0.0399             nan     0.0100    0.0003
##      3        0.0393             nan     0.0100    0.0005
##      4        0.0389             nan     0.0100    0.0004
##      5        0.0385             nan     0.0100    0.0003
##      6        0.0379             nan     0.0100    0.0006
##      7        0.0374             nan     0.0100    0.0003
##      8        0.0367             nan     0.0100    0.0005
##      9        0.0363             nan     0.0100    0.0001
##     10        0.0357             nan     0.0100    0.0005
##     20        0.0320             nan     0.0100    0.0003
##     40        0.0244             nan     0.0100    0.0003
##     60        0.0193             nan     0.0100    0.0002
##     80        0.0152             nan     0.0100    0.0001
##    100        0.0124             nan     0.0100    0.0000
##    120        0.0100             nan     0.0100    0.0001
##    140        0.0081             nan     0.0100    0.0001
##    160        0.0067             nan     0.0100    0.0000
##    180        0.0055             nan     0.0100   -0.0000
##    200        0.0046             nan     0.0100    0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0100    0.0002
##      2        0.0400             nan     0.0100    0.0005
##      3        0.0395             nan     0.0100    0.0003
##      4        0.0390             nan     0.0100    0.0003
##      5        0.0386             nan     0.0100    0.0005
##      6        0.0382             nan     0.0100    0.0003
##      7        0.0379             nan     0.0100    0.0001
##      8        0.0374             nan     0.0100    0.0002
##      9        0.0369             nan     0.0100    0.0005
##     10        0.0365             nan     0.0100    0.0002
##     20        0.0332             nan     0.0100    0.0003
##     40        0.0271             nan     0.0100    0.0001
##     60        0.0224             nan     0.0100    0.0001
##     80        0.0188             nan     0.0100    0.0001
##    100        0.0162             nan     0.0100    0.0001
##    120        0.0140             nan     0.0100    0.0000
##    140        0.0122             nan     0.0100    0.0000
##    160        0.0106             nan     0.0100   -0.0001
##    180        0.0094             nan     0.0100    0.0000
##    200        0.0086             nan     0.0100   -0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0406             nan     0.0100    0.0001
##      2        0.0399             nan     0.0100    0.0006
##      3        0.0396             nan     0.0100   -0.0000
##      4        0.0389             nan     0.0100    0.0005
##      5        0.0383             nan     0.0100    0.0004
##      6        0.0378             nan     0.0100    0.0004
##      7        0.0373             nan     0.0100    0.0003
##      8        0.0369             nan     0.0100    0.0000
##      9        0.0363             nan     0.0100    0.0002
##     10        0.0358             nan     0.0100    0.0005
##     20        0.0311             nan     0.0100    0.0002
##     40        0.0236             nan     0.0100    0.0004
##     60        0.0179             nan     0.0100    0.0002
##     80        0.0134             nan     0.0100    0.0001
##    100        0.0105             nan     0.0100    0.0002
##    120        0.0080             nan     0.0100    0.0000
##    140        0.0063             nan     0.0100   -0.0000
##    160        0.0050             nan     0.0100   -0.0000
##    180        0.0040             nan     0.0100    0.0000
##    200        0.0031             nan     0.0100   -0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0100    0.0005
##      2        0.0397             nan     0.0100    0.0006
##      3        0.0394             nan     0.0100    0.0002
##      4        0.0387             nan     0.0100    0.0007
##      5        0.0381             nan     0.0100    0.0004
##      6        0.0376             nan     0.0100    0.0004
##      7        0.0371             nan     0.0100    0.0005
##      8        0.0365             nan     0.0100    0.0005
##      9        0.0361             nan     0.0100   -0.0001
##     10        0.0356             nan     0.0100    0.0005
##     20        0.0310             nan     0.0100    0.0002
##     40        0.0239             nan     0.0100    0.0003
##     60        0.0188             nan     0.0100    0.0001
##     80        0.0149             nan     0.0100    0.0001
##    100        0.0117             nan     0.0100    0.0001
##    120        0.0095             nan     0.0100    0.0001
##    140        0.0079             nan     0.0100    0.0001
##    160        0.0062             nan     0.0100    0.0001
##    180        0.0050             nan     0.0100   -0.0000
##    200        0.0041             nan     0.0100   -0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0405             nan     0.0100    0.0005
##      2        0.0400             nan     0.0100    0.0006
##      3        0.0396             nan     0.0100    0.0004
##      4        0.0390             nan     0.0100    0.0005
##      5        0.0384             nan     0.0100    0.0005
##      6        0.0379             nan     0.0100    0.0004
##      7        0.0375             nan     0.0100    0.0001
##      8        0.0370             nan     0.0100    0.0004
##      9        0.0367             nan     0.0100    0.0002
##     10        0.0363             nan     0.0100    0.0002
##     20        0.0326             nan     0.0100    0.0002
##     40        0.0262             nan     0.0100    0.0003
##     60        0.0216             nan     0.0100   -0.0002
##     80        0.0182             nan     0.0100    0.0001
##    100        0.0152             nan     0.0100    0.0001
##    120        0.0134             nan     0.0100    0.0001
##    140        0.0118             nan     0.0100    0.0000
##    160        0.0103             nan     0.0100    0.0001
##    180        0.0094             nan     0.0100   -0.0000
##    200        0.0085             nan     0.0100   -0.0000
## 
## - Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.0500    0.0020
##      2        0.0372             nan     0.0500   -0.0003
##      3        0.0348             nan     0.0500    0.0020
##      4        0.0337             nan     0.0500    0.0000
##      5        0.0323             nan     0.0500    0.0016
##      6        0.0305             nan     0.0500    0.0018
##      7        0.0292             nan     0.0500    0.0012
##      8        0.0274             nan     0.0500    0.0011
##      9        0.0260             nan     0.0500    0.0015
##     10        0.0245             nan     0.0500    0.0013
##     20        0.0158             nan     0.0500    0.0004
##     40        0.0068             nan     0.0500    0.0003
##     60        0.0028             nan     0.0500   -0.0000
##     80        0.0013             nan     0.0500   -0.0000
##    100        0.0008             nan     0.0500   -0.0000
##    120        0.0004             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0388             nan     0.0500    0.0025
##      2        0.0361             nan     0.0500    0.0017
##      3        0.0340             nan     0.0500    0.0021
##      4        0.0330             nan     0.0500    0.0005
##      5        0.0307             nan     0.0500    0.0009
##      6        0.0289             nan     0.0500    0.0015
##      7        0.0275             nan     0.0500    0.0014
##      8        0.0262             nan     0.0500    0.0010
##      9        0.0252             nan     0.0500    0.0008
##     10        0.0233             nan     0.0500    0.0016
##     20        0.0142             nan     0.0500    0.0002
##     40        0.0062             nan     0.0500    0.0000
##     60        0.0036             nan     0.0500   -0.0001
##     80        0.0020             nan     0.0500    0.0000
##    100        0.0012             nan     0.0500    0.0000
##    120        0.0008             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500    0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500   -0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0396             nan     0.0500    0.0018
##      2        0.0363             nan     0.0500    0.0023
##      3        0.0346             nan     0.0500    0.0013
##      4        0.0323             nan     0.0500    0.0017
##      5        0.0305             nan     0.0500    0.0015
##      6        0.0294             nan     0.0500    0.0004
##      7        0.0274             nan     0.0500    0.0014
##      8        0.0262             nan     0.0500    0.0013
##      9        0.0253             nan     0.0500    0.0012
##     10        0.0239             nan     0.0500    0.0014
##     20        0.0157             nan     0.0500    0.0005
##     40        0.0089             nan     0.0500   -0.0001
##     60        0.0055             nan     0.0500    0.0000
##     80        0.0034             nan     0.0500   -0.0000
##    100        0.0022             nan     0.0500    0.0001
##    120        0.0017             nan     0.0500   -0.0000
##    140        0.0012             nan     0.0500    0.0000
##    160        0.0009             nan     0.0500   -0.0000
##    180        0.0007             nan     0.0500    0.0000
##    200        0.0005             nan     0.0500   -0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0381             nan     0.0500    0.0013
##      2        0.0353             nan     0.0500    0.0019
##      3        0.0341             nan     0.0500    0.0009
##      4        0.0323             nan     0.0500    0.0022
##      5        0.0302             nan     0.0500    0.0018
##      6        0.0275             nan     0.0500    0.0027
##      7        0.0256             nan     0.0500    0.0011
##      8        0.0245             nan     0.0500    0.0011
##      9        0.0228             nan     0.0500    0.0016
##     10        0.0214             nan     0.0500    0.0007
##     20        0.0112             nan     0.0500   -0.0002
##     40        0.0037             nan     0.0500    0.0001
##     60        0.0015             nan     0.0500    0.0000
##     80        0.0007             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0002             nan     0.0500   -0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500   -0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0380             nan     0.0500    0.0018
##      2        0.0347             nan     0.0500    0.0014
##      3        0.0323             nan     0.0500    0.0015
##      4        0.0297             nan     0.0500    0.0011
##      5        0.0276             nan     0.0500    0.0019
##      6        0.0261             nan     0.0500    0.0009
##      7        0.0244             nan     0.0500    0.0017
##      8        0.0228             nan     0.0500    0.0016
##      9        0.0211             nan     0.0500    0.0002
##     10        0.0205             nan     0.0500    0.0003
##     20        0.0115             nan     0.0500    0.0004
##     40        0.0044             nan     0.0500    0.0001
##     60        0.0022             nan     0.0500    0.0000
##     80        0.0015             nan     0.0500   -0.0000
##    100        0.0010             nan     0.0500   -0.0000
##    120        0.0006             nan     0.0500    0.0000
##    140        0.0005             nan     0.0500   -0.0000
##    160        0.0003             nan     0.0500   -0.0000
##    180        0.0002             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0392             nan     0.0500    0.0011
##      2        0.0376             nan     0.0500    0.0015
##      3        0.0363             nan     0.0500    0.0004
##      4        0.0343             nan     0.0500    0.0008
##      5        0.0323             nan     0.0500    0.0018
##      6        0.0305             nan     0.0500    0.0015
##      7        0.0289             nan     0.0500    0.0017
##      8        0.0279             nan     0.0500    0.0008
##      9        0.0265             nan     0.0500    0.0014
##     10        0.0255             nan     0.0500    0.0007
##     20        0.0174             nan     0.0500    0.0009
##     40        0.0092             nan     0.0500    0.0001
##     60        0.0057             nan     0.0500   -0.0001
##     80        0.0041             nan     0.0500   -0.0000
##    100        0.0029             nan     0.0500   -0.0000
##    120        0.0021             nan     0.0500   -0.0001
##    140        0.0016             nan     0.0500   -0.0000
##    160        0.0012             nan     0.0500   -0.0000
##    180        0.0010             nan     0.0500   -0.0000
##    200        0.0007             nan     0.0500   -0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0369             nan     0.0500    0.0028
##      2        0.0347             nan     0.0500    0.0011
##      3        0.0324             nan     0.0500    0.0020
##      4        0.0304             nan     0.0500    0.0007
##      5        0.0284             nan     0.0500    0.0015
##      6        0.0265             nan     0.0500    0.0010
##      7        0.0247             nan     0.0500    0.0012
##      8        0.0222             nan     0.0500    0.0013
##      9        0.0218             nan     0.0500   -0.0003
##     10        0.0200             nan     0.0500    0.0012
##     20        0.0101             nan     0.0500    0.0005
##     40        0.0037             nan     0.0500   -0.0002
##     60        0.0013             nan     0.0500   -0.0000
##     80        0.0006             nan     0.0500   -0.0000
##    100        0.0003             nan     0.0500    0.0000
##    120        0.0001             nan     0.0500    0.0000
##    140        0.0001             nan     0.0500   -0.0000
##    160        0.0000             nan     0.0500   -0.0000
##    180        0.0000             nan     0.0500   -0.0000
##    200        0.0000             nan     0.0500    0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0385             nan     0.0500    0.0021
##      2        0.0358             nan     0.0500    0.0020
##      3        0.0334             nan     0.0500    0.0013
##      4        0.0304             nan     0.0500    0.0029
##      5        0.0290             nan     0.0500    0.0010
##      6        0.0274             nan     0.0500    0.0013
##      7        0.0258             nan     0.0500    0.0010
##      8        0.0234             nan     0.0500    0.0011
##      9        0.0220             nan     0.0500    0.0010
##     10        0.0214             nan     0.0500    0.0003
##     20        0.0117             nan     0.0500    0.0002
##     40        0.0042             nan     0.0500    0.0001
##     60        0.0019             nan     0.0500   -0.0000
##     80        0.0009             nan     0.0500   -0.0000
##    100        0.0006             nan     0.0500   -0.0000
##    120        0.0003             nan     0.0500    0.0000
##    140        0.0002             nan     0.0500    0.0000
##    160        0.0001             nan     0.0500   -0.0000
##    180        0.0001             nan     0.0500   -0.0000
##    200        0.0001             nan     0.0500    0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0398             nan     0.0500    0.0001
##      2        0.0377             nan     0.0500    0.0010
##      3        0.0352             nan     0.0500    0.0020
##      4        0.0331             nan     0.0500    0.0011
##      5        0.0308             nan     0.0500    0.0019
##      6        0.0293             nan     0.0500    0.0016
##      7        0.0278             nan     0.0500    0.0014
##      8        0.0268             nan     0.0500   -0.0004
##      9        0.0248             nan     0.0500    0.0003
##     10        0.0236             nan     0.0500    0.0008
##     20        0.0154             nan     0.0500    0.0003
##     40        0.0090             nan     0.0500    0.0001
##     60        0.0060             nan     0.0500    0.0000
##     80        0.0040             nan     0.0500   -0.0001
##    100        0.0029             nan     0.0500   -0.0000
##    120        0.0021             nan     0.0500   -0.0001
##    140        0.0016             nan     0.0500   -0.0000
##    160        0.0011             nan     0.0500    0.0000
##    180        0.0009             nan     0.0500   -0.0000
##    200        0.0008             nan     0.0500    0.0000
## 
## - Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0349             nan     0.1000    0.0051
##      2        0.0317             nan     0.1000    0.0014
##      3        0.0298             nan     0.1000   -0.0017
##      4        0.0256             nan     0.1000    0.0024
##      5        0.0226             nan     0.1000    0.0033
##      6        0.0191             nan     0.1000    0.0024
##      7        0.0182             nan     0.1000    0.0003
##      8        0.0177             nan     0.1000   -0.0007
##      9        0.0153             nan     0.1000    0.0010
##     10        0.0146             nan     0.1000   -0.0003
##     20        0.0063             nan     0.1000    0.0006
##     40        0.0020             nan     0.1000   -0.0000
##     60        0.0008             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0359             nan     0.1000    0.0053
##      2        0.0301             nan     0.1000    0.0042
##      3        0.0265             nan     0.1000    0.0024
##      4        0.0240             nan     0.1000    0.0028
##      5        0.0203             nan     0.1000    0.0033
##      6        0.0192             nan     0.1000    0.0013
##      7        0.0168             nan     0.1000    0.0003
##      8        0.0151             nan     0.1000    0.0011
##      9        0.0146             nan     0.1000   -0.0000
##     10        0.0133             nan     0.1000    0.0009
##     20        0.0058             nan     0.1000   -0.0001
##     40        0.0016             nan     0.1000    0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000   -0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0397             nan     0.1000   -0.0025
##      2        0.0342             nan     0.1000    0.0049
##      3        0.0306             nan     0.1000    0.0033
##      4        0.0285             nan     0.1000    0.0020
##      5        0.0259             nan     0.1000    0.0025
##      6        0.0235             nan     0.1000    0.0023
##      7        0.0222             nan     0.1000    0.0008
##      8        0.0205             nan     0.1000    0.0014
##      9        0.0192             nan     0.1000    0.0003
##     10        0.0178             nan     0.1000    0.0008
##     20        0.0094             nan     0.1000    0.0004
##     40        0.0047             nan     0.1000    0.0002
##     60        0.0025             nan     0.1000   -0.0001
##     80        0.0015             nan     0.1000   -0.0000
##    100        0.0007             nan     0.1000   -0.0000
##    120        0.0004             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000    0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0377             nan     0.1000    0.0007
##      2        0.0328             nan     0.1000    0.0037
##      3        0.0291             nan     0.1000   -0.0007
##      4        0.0252             nan     0.1000    0.0032
##      5        0.0217             nan     0.1000    0.0024
##      6        0.0186             nan     0.1000    0.0016
##      7        0.0172             nan     0.1000    0.0002
##      8        0.0171             nan     0.1000   -0.0014
##      9        0.0154             nan     0.1000    0.0015
##     10        0.0142             nan     0.1000    0.0009
##     20        0.0040             nan     0.1000    0.0005
##     40        0.0008             nan     0.1000   -0.0000
##     60        0.0002             nan     0.1000   -0.0000
##     80        0.0001             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000    0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0358             nan     0.1000    0.0057
##      2        0.0332             nan     0.1000    0.0015
##      3        0.0299             nan     0.1000    0.0032
##      4        0.0257             nan     0.1000    0.0034
##      5        0.0248             nan     0.1000   -0.0006
##      6        0.0228             nan     0.1000    0.0002
##      7        0.0223             nan     0.1000   -0.0011
##      8        0.0208             nan     0.1000    0.0009
##      9        0.0197             nan     0.1000    0.0015
##     10        0.0181             nan     0.1000    0.0003
##     20        0.0063             nan     0.1000   -0.0004
##     40        0.0014             nan     0.1000   -0.0000
##     60        0.0006             nan     0.1000    0.0000
##     80        0.0002             nan     0.1000   -0.0000
##    100        0.0001             nan     0.1000    0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0379             nan     0.1000    0.0014
##      2        0.0336             nan     0.1000    0.0045
##      3        0.0291             nan     0.1000    0.0039
##      4        0.0272             nan     0.1000    0.0004
##      5        0.0246             nan     0.1000    0.0027
##      6        0.0235             nan     0.1000    0.0003
##      7        0.0216             nan     0.1000    0.0010
##      8        0.0205             nan     0.1000    0.0010
##      9        0.0186             nan     0.1000    0.0019
##     10        0.0176             nan     0.1000   -0.0005
##     20        0.0098             nan     0.1000    0.0001
##     40        0.0043             nan     0.1000   -0.0002
##     60        0.0022             nan     0.1000   -0.0001
##     80        0.0011             nan     0.1000   -0.0000
##    100        0.0006             nan     0.1000   -0.0000
##    120        0.0003             nan     0.1000   -0.0000
##    140        0.0002             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0372             nan     0.1000    0.0038
##      2        0.0330             nan     0.1000    0.0040
##      3        0.0272             nan     0.1000    0.0030
##      4        0.0242             nan     0.1000    0.0011
##      5        0.0217             nan     0.1000    0.0030
##      6        0.0185             nan     0.1000    0.0029
##      7        0.0157             nan     0.1000    0.0011
##      8        0.0150             nan     0.1000   -0.0002
##      9        0.0125             nan     0.1000    0.0012
##     10        0.0120             nan     0.1000    0.0002
##     20        0.0036             nan     0.1000   -0.0005
##     40        0.0007             nan     0.1000    0.0000
##     60        0.0001             nan     0.1000   -0.0000
##     80        0.0000             nan     0.1000   -0.0000
##    100        0.0000             nan     0.1000   -0.0000
##    120        0.0000             nan     0.1000   -0.0000
##    140        0.0000             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000    0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0354             nan     0.1000    0.0036
##      2        0.0323             nan     0.1000    0.0030
##      3        0.0271             nan     0.1000    0.0043
##      4        0.0240             nan     0.1000    0.0032
##      5        0.0222             nan     0.1000    0.0017
##      6        0.0207             nan     0.1000    0.0014
##      7        0.0189             nan     0.1000    0.0015
##      8        0.0155             nan     0.1000    0.0011
##      9        0.0142             nan     0.1000    0.0007
##     10        0.0122             nan     0.1000    0.0014
##     20        0.0050             nan     0.1000    0.0000
##     40        0.0017             nan     0.1000   -0.0001
##     60        0.0006             nan     0.1000   -0.0000
##     80        0.0003             nan     0.1000   -0.0000
##    100        0.0002             nan     0.1000    0.0000
##    120        0.0001             nan     0.1000   -0.0000
##    140        0.0001             nan     0.1000   -0.0000
##    160        0.0000             nan     0.1000   -0.0000
##    180        0.0000             nan     0.1000   -0.0000
##    200        0.0000             nan     0.1000   -0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
## + Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0350             nan     0.1000    0.0048
##      2        0.0328             nan     0.1000    0.0007
##      3        0.0307             nan     0.1000    0.0004
##      4        0.0269             nan     0.1000    0.0035
##      5        0.0248             nan     0.1000    0.0016
##      6        0.0227             nan     0.1000    0.0015
##      7        0.0202             nan     0.1000    0.0018
##      8        0.0193             nan     0.1000    0.0005
##      9        0.0184             nan     0.1000    0.0005
##     10        0.0172             nan     0.1000    0.0007
##     20        0.0085             nan     0.1000    0.0000
##     40        0.0040             nan     0.1000   -0.0000
##     60        0.0018             nan     0.1000   -0.0000
##     80        0.0012             nan     0.1000   -0.0001
##    100        0.0008             nan     0.1000   -0.0000
##    120        0.0005             nan     0.1000   -0.0000
##    140        0.0003             nan     0.1000   -0.0000
##    160        0.0002             nan     0.1000   -0.0000
##    180        0.0001             nan     0.1000   -0.0000
##    200        0.0001             nan     0.1000    0.0000
## 
## - Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
## Aggregating results
## Selecting tuning parameters
## Fitting n.trees = 200, interaction.depth = 1, shrinkage = 0.05, n.minobsinnode = 1 on full training set
## Iter   TrainDeviance   ValidDeviance   StepSize   Improve
##      1        0.0403             nan     0.0500    0.0023
##      2        0.0378             nan     0.0500    0.0028
##      3        0.0362             nan     0.0500    0.0014
##      4        0.0334             nan     0.0500    0.0024
##      5        0.0328             nan     0.0500   -0.0006
##      6        0.0311             nan     0.0500    0.0010
##      7        0.0295             nan     0.0500    0.0014
##      8        0.0275             nan     0.0500    0.0021
##      9        0.0261             nan     0.0500    0.0005
##     10        0.0248             nan     0.0500    0.0013
##     20        0.0145             nan     0.0500    0.0006
##     40        0.0061             nan     0.0500    0.0002
##     60        0.0032             nan     0.0500    0.0000
##     80        0.0017             nan     0.0500   -0.0000
##    100        0.0009             nan     0.0500   -0.0000
##    120        0.0005             nan     0.0500   -0.0000
##    140        0.0003             nan     0.0500    0.0000
##    160        0.0002             nan     0.0500    0.0000
##    180        0.0001             nan     0.0500    0.0000
##    200        0.0001             nan     0.0500    0.0000

Brad’s theory notes

Leaving this section here, it is to be deleted as we incorporate what we need from here into the explanatory model part

Running a different logistic model for each country

We now have a table to test some glmer modelling on.

Following this tutorial Marga sent and applying to the test data:

https://raffaelevacca.github.io/Intro-multilevel-with-R/

Testing a nested dataset by country

# Commented the below as we are probably not gonna use it
# 
# nested.cntry <- complete_df %>%
#   group_by(country) %>%
#   nest()
# 
# # The column nested.df$data is a list of data frames, one for each country
# class(nested.cntry$data) # type, list
# length(nested.cntry$data) # number of countries
# 
# # to unnest()
# nested.cntry %>%
#   filter(country == "AT") %>%
#   dplyr::select(country, data) %>%
#   unnest(cols = c(data))

# # Using the nested data, we now run a model for each country:

# # fit separate lm for each each element of nested.cntry$data)
# lmodels <- nested.cntry %>%
#   # Get all data frames
#   pull(data) %>%
#   # Run glm() on each via map because it's a classification model
#     # model run against all vairables for now. 
#   purrr::map(~ glm(trans_docs ~ ., 
#                    data= .x,
#                    family = "binomial"))
# 
# # show that it's a list and we can call each elements regression output. 
# class(lmodels)
# lmodels[4]

Mixed models

Fixed effects: Things that are the same across the cluster Random effects: Things that change within the cluster

The fixed and random effects could refer to either the intercept or the slope, as these can both vary between groups.

LMM equation structure in R

To run a multilevel linear model, we use the lmer() function (“Linear Mixed Effects in R”) from the lme4 package. The syntax is similar to regression. everything to the left of the | indicates the effects that should be random, and the variable to the right of the | is the grouping variable across which the effects should vary

Null model This has no slope, but random intercepts. It basically just takes the average. It has no independent (X) variables and is the proper naïve model.

null_model <- lmer(Y ~ (1|cntry), data = ess)

Random intercept model: –> Only the intercept differ. The slopes are equal for each group. We assume the same effect of X on Y for each group. Just that the group causes the difference.

random_int_model <- lmer(Y ~ X + (1 | group), data=df)

Random intercept, random slope model –> Now we also let the slope vary by group. This means each group basically has it’s own model. It is

random_intslope_model <- lmer(Y ~ X + (X | group), data=df)

For each, Y=target, X = independent vars (can be many)

Standard LMM Modelling Strategy

(sourced from slides here: https://favstats.github.io/intro_multilevel/slides/#54) ^ This is a useful resource, it goes through an ESS modelling doc

Approach to multilevel model building based on Hox (2010)

1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions

Each step, check whether your model is significantly improved compared to the previous one.

Basic LMM testing with toy data

First, null model:

# m_null <- glmer(trans_docs ~ (1|country),
#                data = complete_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)
# summary(m_null)

To come back and reinterpret… don’t really know at this stage.

Test flexplot and broom.mixed usage:

# #devtools::install_github("dustinfife/flexplot")
# library(flexplot)

Here it has some examples of code and output for saved logistic model fits

# # don't think flexplot will be super useful as we have so many categorical variables
# flexplot::logistic_fit
# flexplot::mixed_logistic
# flexplot::visualize(m_null)
# 
# # broom.mixed is used to tidy up the stats outputs into a tibble
# broom.mixed::tidy(m_null) # summary output in tibble
# broom.mixed::glance(m_null) # model performance summary

Random effects model

  • Including individual level variables only with country:
# n_randeffect <- glmer(trans_docs ~ 
#                         gender + age + I(age^2) + life_sat + religion + social_class + 
#                         (1|country),
#                data = complete_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)

This suggests the data needs to be rescaled, to check which variables are the issue:

# # check for nearzero variance, if so those could be removed
# nearZeroVar(complete_df, saveMetrics = TRUE)
# # see no issues. So all variables stay.
# 
# # will recode the numeric variables I selected, which is only age
# scaled_df <- complete_df |>
#   mutate(across(where(is.numeric), scale))

Re check the random effects model with scaled data:

# n_randeffect <- glmer(trans_docs ~
#                         gender + age + I(age^2) + life_sat + (1|country),
#                data = scaled_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)
# 
# 
# 
# summary(n_randeffect)

Can we interpret this…

Example Random effects models: m <- glmer(remission ~ IL6 + CRP + CancerStage + LengthofStay + Experience + (1 | DID), data = hdp, family = binomial, control = glmerControl(optimizer = “bobyqa”), nAGQ = 10)

Example from last year code glm_model_4 <- glmer(binary_qc19 ~ male + d11 + I(d11^2) + political_ideology + Religion_cat + sd1_7_factor + d60_ordinal + qc15_1_ordinal + prop_gndr_bin + prop_dis_wide + Unemployment + (1 | country_name), data = Data, family = binomial, control = glmerControl(optimizer = “bobyqa”, optCtrl = list(maxfun = 100000)))

Potentially useful package for visualising and interpreting linear mixed models: Flexplot -> https://github.com/dustinfife/flexplot Functions to quickly visualise LMM models and compare their performance.

broom.mixed The function broom.mixed::tidy() gives us all model parameters (random and fixed).

Useful calculations: - ICC (intra cluster correlation. How alike each of the observations within each group are) - ANOVA for model comparison: anova(null_model, lvl1_preds_model, lvl2_preds_model, rs_preds_model)